1/* This file is automatically generated by aarch64-gen.  Do not edit!  */
2/* Copyright (C) 2012-2017 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 1155;
44                    }
45                  else
46                    {
47                      /* 33222222222211111111110000000000
48                         10987654321098765432109876543210
49                         xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
50                         adrp.  */
51                      return 1156;
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 910;
119                                            }
120                                          else
121                                            {
122                                              /* 33222222222211111111110000000000
123                                                 10987654321098765432109876543210
124                                                 xxxxxxxxxxxxxxx0xxxxx000x0010010
125                                                 stxrh.  */
126                                              return 916;
127                                            }
128                                        }
129                                      else
130                                        {
131                                          /* 33222222222211111111110000000000
132                                             10987654321098765432109876543210
133                                             xxxxxxxxxxxxxxx0xxxxx000x00100x1
134                                             stxr.  */
135                                          return 922;
136                                        }
137                                    }
138                                  else
139                                    {
140                                      if (((word >> 31) & 0x1) == 0)
141                                        {
142                                          /* 33222222222211111111110000000000
143                                             10987654321098765432109876543210
144                                             xxxxxxxxxxxxxxx0xxxxx100x00100x0
145                                             casp.  */
146                                          return 990;
147                                        }
148                                      else
149                                        {
150                                          /* 33222222222211111111110000000000
151                                             10987654321098765432109876543210
152                                             xxxxxxxxxxxxxxx0xxxxx100x00100x1
153                                             stxp.  */
154                                          return 924;
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 911;
171                                            }
172                                          else
173                                            {
174                                              /* 33222222222211111111110000000000
175                                                 10987654321098765432109876543210
176                                                 xxxxxxxxxxxxxxx1xxxxx000x0010010
177                                                 stlxrh.  */
178                                              return 917;
179                                            }
180                                        }
181                                      else
182                                        {
183                                          /* 33222222222211111111110000000000
184                                             10987654321098765432109876543210
185                                             xxxxxxxxxxxxxxx1xxxxx000x00100x1
186                                             stlxr.  */
187                                          return 923;
188                                        }
189                                    }
190                                  else
191                                    {
192                                      if (((word >> 31) & 0x1) == 0)
193                                        {
194                                          /* 33222222222211111111110000000000
195                                             10987654321098765432109876543210
196                                             xxxxxxxxxxxxxxx1xxxxx100x00100x0
197                                             caspl.  */
198                                          return 992;
199                                        }
200                                      else
201                                        {
202                                          /* 33222222222211111111110000000000
203                                             10987654321098765432109876543210
204                                             xxxxxxxxxxxxxxx1xxxxx100x00100x1
205                                             stlxp.  */
206                                          return 925;
207                                        }
208                                    }
209                                }
210                            }
211                          else
212                            {
213                              /* 33222222222211111111110000000000
214                                 10987654321098765432109876543210
215                                 xxxxxxxxxxxxxxxxxxxxxx00x00101xx
216                                 stnp.  */
217                              return 941;
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 939;
235                                        }
236                                      else
237                                        {
238                                          /* 33222222222211111111110000000000
239                                             10987654321098765432109876543210
240                                             xxxxxxxxxxxxxxx0xxxxx001x00100x1
241                                             stllr.  */
242                                          return 938;
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 978;
256                                            }
257                                          else
258                                            {
259                                              /* 33222222222211111111110000000000
260                                                 10987654321098765432109876543210
261                                                 xxxxxxxxxxxxxxx0xxxxx101x0010010
262                                                 cash.  */
263                                              return 979;
264                                            }
265                                        }
266                                      else
267                                        {
268                                          /* 33222222222211111111110000000000
269                                             10987654321098765432109876543210
270                                             xxxxxxxxxxxxxxx0xxxxx101x00100x1
271                                             cas.  */
272                                          return 980;
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 914;
289                                            }
290                                          else
291                                            {
292                                              /* 33222222222211111111110000000000
293                                                 10987654321098765432109876543210
294                                                 xxxxxxxxxxxxxxx1xxxxx001x0010010
295                                                 stlrh.  */
296                                              return 920;
297                                            }
298                                        }
299                                      else
300                                        {
301                                          /* 33222222222211111111110000000000
302                                             10987654321098765432109876543210
303                                             xxxxxxxxxxxxxxx1xxxxx001x00100x1
304                                             stlr.  */
305                                          return 930;
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 982;
319                                            }
320                                          else
321                                            {
322                                              /* 33222222222211111111110000000000
323                                                 10987654321098765432109876543210
324                                                 xxxxxxxxxxxxxxx1xxxxx101x0010010
325                                                 caslh.  */
326                                              return 985;
327                                            }
328                                        }
329                                      else
330                                        {
331                                          /* 33222222222211111111110000000000
332                                             10987654321098765432109876543210
333                                             xxxxxxxxxxxxxxx1xxxxx101x00100x1
334                                             casl.  */
335                                          return 988;
336                                        }
337                                    }
338                                }
339                            }
340                          else
341                            {
342                              /* 33222222222211111111110000000000
343                                 10987654321098765432109876543210
344                                 xxxxxxxxxxxxxxxxxxxxxx01x00101xx
345                                 stp.  */
346                              return 950;
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 912;
369                                            }
370                                          else
371                                            {
372                                              /* 33222222222211111111110000000000
373                                                 10987654321098765432109876543210
374                                                 xxxxxxxxxxxxxxx0xxxxx010x0010010
375                                                 ldxrh.  */
376                                              return 918;
377                                            }
378                                        }
379                                      else
380                                        {
381                                          /* 33222222222211111111110000000000
382                                             10987654321098765432109876543210
383                                             xxxxxxxxxxxxxxx0xxxxx010x00100x1
384                                             ldxr.  */
385                                          return 926;
386                                        }
387                                    }
388                                  else
389                                    {
390                                      if (((word >> 31) & 0x1) == 0)
391                                        {
392                                          /* 33222222222211111111110000000000
393                                             10987654321098765432109876543210
394                                             xxxxxxxxxxxxxxx0xxxxx110x00100x0
395                                             caspa.  */
396                                          return 991;
397                                        }
398                                      else
399                                        {
400                                          /* 33222222222211111111110000000000
401                                             10987654321098765432109876543210
402                                             xxxxxxxxxxxxxxx0xxxxx110x00100x1
403                                             ldxp.  */
404                                          return 928;
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 913;
421                                            }
422                                          else
423                                            {
424                                              /* 33222222222211111111110000000000
425                                                 10987654321098765432109876543210
426                                                 xxxxxxxxxxxxxxx1xxxxx010x0010010
427                                                 ldaxrh.  */
428                                              return 919;
429                                            }
430                                        }
431                                      else
432                                        {
433                                          /* 33222222222211111111110000000000
434                                             10987654321098765432109876543210
435                                             xxxxxxxxxxxxxxx1xxxxx010x00100x1
436                                             ldaxr.  */
437                                          return 927;
438                                        }
439                                    }
440                                  else
441                                    {
442                                      if (((word >> 31) & 0x1) == 0)
443                                        {
444                                          /* 33222222222211111111110000000000
445                                             10987654321098765432109876543210
446                                             xxxxxxxxxxxxxxx1xxxxx110x00100x0
447                                             caspal.  */
448                                          return 993;
449                                        }
450                                      else
451                                        {
452                                          /* 33222222222211111111110000000000
453                                             10987654321098765432109876543210
454                                             xxxxxxxxxxxxxxx1xxxxx110x00100x1
455                                             ldaxp.  */
456                                          return 929;
457                                        }
458                                    }
459                                }
460                            }
461                          else
462                            {
463                              if (((word >> 30) & 0x1) == 0)
464                                {
465                                  /* 33222222222211111111110000000000
466                                     10987654321098765432109876543210
467                                     xxxxxxxxxxxxxxxxxxxxxx10x001010x
468                                     ldnp.  */
469                                  return 942;
470                                }
471                              else
472                                {
473                                  /* 33222222222211111111110000000000
474                                     10987654321098765432109876543210
475                                     xxxxxxxxxxxxxxxxxxxxxx10x001011x
476                                     ldpsw.  */
477                                  return 949;
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 936;
498                                            }
499                                          else
500                                            {
501                                              /* 33222222222211111111110000000000
502                                                 10987654321098765432109876543210
503                                                 xxxxxxxxxxxxxxx0xxxxx011x0010010
504                                                 ldlarh.  */
505                                              return 937;
506                                            }
507                                        }
508                                      else
509                                        {
510                                          /* 33222222222211111111110000000000
511                                             10987654321098765432109876543210
512                                             xxxxxxxxxxxxxxx0xxxxx011x00100x1
513                                             ldlar.  */
514                                          return 935;
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 981;
528                                            }
529                                          else
530                                            {
531                                              /* 33222222222211111111110000000000
532                                                 10987654321098765432109876543210
533                                                 xxxxxxxxxxxxxxx0xxxxx111x0010010
534                                                 casah.  */
535                                              return 984;
536                                            }
537                                        }
538                                      else
539                                        {
540                                          /* 33222222222211111111110000000000
541                                             10987654321098765432109876543210
542                                             xxxxxxxxxxxxxxx0xxxxx111x00100x1
543                                             casa.  */
544                                          return 987;
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 915;
561                                            }
562                                          else
563                                            {
564                                              /* 33222222222211111111110000000000
565                                                 10987654321098765432109876543210
566                                                 xxxxxxxxxxxxxxx1xxxxx011x0010010
567                                                 ldarh.  */
568                                              return 921;
569                                            }
570                                        }
571                                      else
572                                        {
573                                          /* 33222222222211111111110000000000
574                                             10987654321098765432109876543210
575                                             xxxxxxxxxxxxxxx1xxxxx011x00100x1
576                                             ldar.  */
577                                          return 931;
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 983;
591                                            }
592                                          else
593                                            {
594                                              /* 33222222222211111111110000000000
595                                                 10987654321098765432109876543210
596                                                 xxxxxxxxxxxxxxx1xxxxx111x0010010
597                                                 casalh.  */
598                                              return 986;
599                                            }
600                                        }
601                                      else
602                                        {
603                                          /* 33222222222211111111110000000000
604                                             10987654321098765432109876543210
605                                             xxxxxxxxxxxxxxx1xxxxx111x00100x1
606                                             casal.  */
607                                          return 989;
608                                        }
609                                    }
610                                }
611                            }
612                          else
613                            {
614                              if (((word >> 30) & 0x1) == 0)
615                                {
616                                  /* 33222222222211111111110000000000
617                                     10987654321098765432109876543210
618                                     xxxxxxxxxxxxxxxxxxxxxx11x001010x
619                                     ldp.  */
620                                  return 951;
621                                }
622                              else
623                                {
624                                  /* 33222222222211111111110000000000
625                                     10987654321098765432109876543210
626                                     xxxxxxxxxxxxxxxxxxxxxx11x001011x
627                                     ldpsw.  */
628                                  return 954;
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 955;
647                            }
648                          else
649                            {
650                              if (((word >> 30) & 0x1) == 0)
651                                {
652                                  /* 33222222222211111111110000000000
653                                     10987654321098765432109876543210
654                                     xxxxxxxxxxxxxxxxxxxxxxxx00011001
655                                     ldrsw.  */
656                                  return 957;
657                                }
658                              else
659                                {
660                                  /* 33222222222211111111110000000000
661                                     10987654321098765432109876543210
662                                     xxxxxxxxxxxxxxxxxxxxxxxx00011011
663                                     prfm.  */
664                                  return 958;
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 896;
689                                                    }
690                                                  else
691                                                    {
692                                                      /* 33222222222211111111110000000000
693                                                         10987654321098765432109876543210
694                                                         xxxxxxxxxx00xxxxxxxxx00000011110
695                                                         sturh.  */
696                                                      return 901;
697                                                    }
698                                                }
699                                              else
700                                                {
701                                                  /* 33222222222211111111110000000000
702                                                     10987654321098765432109876543210
703                                                     xxxxxxxxxx00xxxxxxxxx000000111x1
704                                                     stur.  */
705                                                  return 904;
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 897;
719                                                    }
720                                                  else
721                                                    {
722                                                      /* 33222222222211111111110000000000
723                                                         10987654321098765432109876543210
724                                                         xxxxxxxxxx00xxxxxxxxx01000011110
725                                                         ldurh.  */
726                                                      return 902;
727                                                    }
728                                                }
729                                              else
730                                                {
731                                                  /* 33222222222211111111110000000000
732                                                     10987654321098765432109876543210
733                                                     xxxxxxxxxx00xxxxxxxxx010000111x1
734                                                     ldur.  */
735                                                  return 905;
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 898;
750                                                }
751                                              else
752                                                {
753                                                  /* 33222222222211111111110000000000
754                                                     10987654321098765432109876543210
755                                                     xxxxxxxxxx00xxxxxxxxx0x100011101
756                                                     ldursw.  */
757                                                  return 906;
758                                                }
759                                            }
760                                          else
761                                            {
762                                              if (((word >> 31) & 0x1) == 0)
763                                                {
764                                                  /* 33222222222211111111110000000000
765                                                     10987654321098765432109876543210
766                                                     xxxxxxxxxx00xxxxxxxxx0x100011110
767                                                     ldursh.  */
768                                                  return 903;
769                                                }
770                                              else
771                                                {
772                                                  /* 33222222222211111111110000000000
773                                                     10987654321098765432109876543210
774                                                     xxxxxxxxxx00xxxxxxxxx0x100011111
775                                                     prfum.  */
776                                                  return 907;
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 1006;
804                                                                    }
805                                                                  else
806                                                                    {
807                                                                      /* 33222222222211111111110000000000
808                                                                         10987654321098765432109876543210
809                                                                         xxxxxxxxxx000000xxxxx10000011110
810                                                                         ldaddh.  */
811                                                                      return 1007;
812                                                                    }
813                                                                }
814                                                              else
815                                                                {
816                                                                  /* 33222222222211111111110000000000
817                                                                     10987654321098765432109876543210
818                                                                     xxxxxxxxxx000000xxxxx100000111x1
819                                                                     ldadd.  */
820                                                                  return 1008;
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 1009;
834                                                                    }
835                                                                  else
836                                                                    {
837                                                                      /* 33222222222211111111110000000000
838                                                                         10987654321098765432109876543210
839                                                                         xxxxxxxxxx000000xxxxx10100011110
840                                                                         ldaddah.  */
841                                                                      return 1012;
842                                                                    }
843                                                                }
844                                                              else
845                                                                {
846                                                                  /* 33222222222211111111110000000000
847                                                                     10987654321098765432109876543210
848                                                                     xxxxxxxxxx000000xxxxx101000111x1
849                                                                     ldadda.  */
850                                                                  return 1015;
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 1010;
867                                                                    }
868                                                                  else
869                                                                    {
870                                                                      /* 33222222222211111111110000000000
871                                                                         10987654321098765432109876543210
872                                                                         xxxxxxxxxx000000xxxxx11000011110
873                                                                         ldaddlh.  */
874                                                                      return 1013;
875                                                                    }
876                                                                }
877                                                              else
878                                                                {
879                                                                  /* 33222222222211111111110000000000
880                                                                     10987654321098765432109876543210
881                                                                     xxxxxxxxxx000000xxxxx110000111x1
882                                                                     ldaddl.  */
883                                                                  return 1016;
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 1011;
897                                                                    }
898                                                                  else
899                                                                    {
900                                                                      /* 33222222222211111111110000000000
901                                                                         10987654321098765432109876543210
902                                                                         xxxxxxxxxx000000xxxxx11100011110
903                                                                         ldaddalh.  */
904                                                                      return 1014;
905                                                                    }
906                                                                }
907                                                              else
908                                                                {
909                                                                  /* 33222222222211111111110000000000
910                                                                     10987654321098765432109876543210
911                                                                     xxxxxxxxxx000000xxxxx111000111x1
912                                                                     ldaddal.  */
913                                                                  return 1017;
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 994;
933                                                                    }
934                                                                  else
935                                                                    {
936                                                                      /* 33222222222211111111110000000000
937                                                                         10987654321098765432109876543210
938                                                                         xxxxxxxxxx000001xxxxx10000011110
939                                                                         swph.  */
940                                                                      return 995;
941                                                                    }
942                                                                }
943                                                              else
944                                                                {
945                                                                  /* 33222222222211111111110000000000
946                                                                     10987654321098765432109876543210
947                                                                     xxxxxxxxxx000001xxxxx100000111x1
948                                                                     swp.  */
949                                                                  return 996;
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 997;
963                                                                    }
964                                                                  else
965                                                                    {
966                                                                      /* 33222222222211111111110000000000
967                                                                         10987654321098765432109876543210
968                                                                         xxxxxxxxxx000001xxxxx10100011110
969                                                                         swpah.  */
970                                                                      return 1000;
971                                                                    }
972                                                                }
973                                                              else
974                                                                {
975                                                                  /* 33222222222211111111110000000000
976                                                                     10987654321098765432109876543210
977                                                                     xxxxxxxxxx000001xxxxx101000111x1
978                                                                     swpa.  */
979                                                                  return 1003;
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 998;
996                                                                    }
997                                                                  else
998                                                                    {
999                                                                      /* 33222222222211111111110000000000
1000                                                                         10987654321098765432109876543210
1001                                                                         xxxxxxxxxx000001xxxxx11000011110
1002                                                                         swplh.  */
1003                                                                      return 1001;
1004                                                                    }
1005                                                                }
1006                                                              else
1007                                                                {
1008                                                                  /* 33222222222211111111110000000000
1009                                                                     10987654321098765432109876543210
1010                                                                     xxxxxxxxxx000001xxxxx110000111x1
1011                                                                     swpl.  */
1012                                                                  return 1004;
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 999;
1026                                                                    }
1027                                                                  else
1028                                                                    {
1029                                                                      /* 33222222222211111111110000000000
1030                                                                         10987654321098765432109876543210
1031                                                                         xxxxxxxxxx000001xxxxx11100011110
1032                                                                         swpalh.  */
1033                                                                      return 1002;
1034                                                                    }
1035                                                                }
1036                                                              else
1037                                                                {
1038                                                                  /* 33222222222211111111110000000000
1039                                                                     10987654321098765432109876543210
1040                                                                     xxxxxxxxxx000001xxxxx111000111x1
1041                                                                     swpal.  */
1042                                                                  return 1005;
1043                                                                }
1044                                                            }
1045                                                        }
1046                                                    }
1047                                                }
1048                                              else
1049                                                {
1050                                                  if (((word >> 15) & 0x1) == 0)
1051                                                    {
1052                                                      if (((word >> 22) & 0x1) == 0)
1053                                                        {
1054                                                          if (((word >> 23) & 0x1) == 0)
1055                                                            {
1056                                                              if (((word >> 31) & 0x1) == 0)
1057                                                                {
1058                                                                  if (((word >> 30) & 0x1) == 0)
1059                                                                    {
1060                                                                      /* 33222222222211111111110000000000
1061                                                                         10987654321098765432109876543210
1062                                                                         xxxxxxxxxx000010xxxxx10000011100
1063                                                                         ldsmaxb.  */
1064                                                                      return 1054;
1065                                                                    }
1066                                                                  else
1067                                                                    {
1068                                                                      /* 33222222222211111111110000000000
1069                                                                         10987654321098765432109876543210
1070                                                                         xxxxxxxxxx000010xxxxx10000011110
1071                                                                         ldsmaxh.  */
1072                                                                      return 1055;
1073                                                                    }
1074                                                                }
1075                                                              else
1076                                                                {
1077                                                                  /* 33222222222211111111110000000000
1078                                                                     10987654321098765432109876543210
1079                                                                     xxxxxxxxxx000010xxxxx100000111x1
1080                                                                     ldsmax.  */
1081                                                                  return 1056;
1082                                                                }
1083                                                            }
1084                                                          else
1085                                                            {
1086                                                              if (((word >> 31) & 0x1) == 0)
1087                                                                {
1088                                                                  if (((word >> 30) & 0x1) == 0)
1089                                                                    {
1090                                                                      /* 33222222222211111111110000000000
1091                                                                         10987654321098765432109876543210
1092                                                                         xxxxxxxxxx000010xxxxx10100011100
1093                                                                         ldsmaxab.  */
1094                                                                      return 1057;
1095                                                                    }
1096                                                                  else
1097                                                                    {
1098                                                                      /* 33222222222211111111110000000000
1099                                                                         10987654321098765432109876543210
1100                                                                         xxxxxxxxxx000010xxxxx10100011110
1101                                                                         ldsmaxah.  */
1102                                                                      return 1060;
1103                                                                    }
1104                                                                }
1105                                                              else
1106                                                                {
1107                                                                  /* 33222222222211111111110000000000
1108                                                                     10987654321098765432109876543210
1109                                                                     xxxxxxxxxx000010xxxxx101000111x1
1110                                                                     ldsmaxa.  */
1111                                                                  return 1063;
1112                                                                }
1113                                                            }
1114                                                        }
1115                                                      else
1116                                                        {
1117                                                          if (((word >> 23) & 0x1) == 0)
1118                                                            {
1119                                                              if (((word >> 31) & 0x1) == 0)
1120                                                                {
1121                                                                  if (((word >> 30) & 0x1) == 0)
1122                                                                    {
1123                                                                      /* 33222222222211111111110000000000
1124                                                                         10987654321098765432109876543210
1125                                                                         xxxxxxxxxx000010xxxxx11000011100
1126                                                                         ldsmaxlb.  */
1127                                                                      return 1058;
1128                                                                    }
1129                                                                  else
1130                                                                    {
1131                                                                      /* 33222222222211111111110000000000
1132                                                                         10987654321098765432109876543210
1133                                                                         xxxxxxxxxx000010xxxxx11000011110
1134                                                                         ldsmaxlh.  */
1135                                                                      return 1061;
1136                                                                    }
1137                                                                }
1138                                                              else
1139                                                                {
1140                                                                  /* 33222222222211111111110000000000
1141                                                                     10987654321098765432109876543210
1142                                                                     xxxxxxxxxx000010xxxxx110000111x1
1143                                                                     ldsmaxl.  */
1144                                                                  return 1064;
1145                                                                }
1146                                                            }
1147                                                          else
1148                                                            {
1149                                                              if (((word >> 31) & 0x1) == 0)
1150                                                                {
1151                                                                  if (((word >> 30) & 0x1) == 0)
1152                                                                    {
1153                                                                      /* 33222222222211111111110000000000
1154                                                                         10987654321098765432109876543210
1155                                                                         xxxxxxxxxx000010xxxxx11100011100
1156                                                                         ldsmaxalb.  */
1157                                                                      return 1059;
1158                                                                    }
1159                                                                  else
1160                                                                    {
1161                                                                      /* 33222222222211111111110000000000
1162                                                                         10987654321098765432109876543210
1163                                                                         xxxxxxxxxx000010xxxxx11100011110
1164                                                                         ldsmaxalh.  */
1165                                                                      return 1062;
1166                                                                    }
1167                                                                }
1168                                                              else
1169                                                                {
1170                                                                  /* 33222222222211111111110000000000
1171                                                                     10987654321098765432109876543210
1172                                                                     xxxxxxxxxx000010xxxxx111000111x1
1173                                                                     ldsmaxal.  */
1174                                                                  return 1065;
1175                                                                }
1176                                                            }
1177                                                        }
1178                                                    }
1179                                                  else
1180                                                    {
1181                                                      if (((word >> 31) & 0x1) == 0)
1182                                                        {
1183                                                          if (((word >> 30) & 0x1) == 0)
1184                                                            {
1185                                                              /* 33222222222211111111110000000000
1186                                                                 10987654321098765432109876543210
1187                                                                 xxxxxxxxxx000011xxxxx1xx00011100
1188                                                                 ldaprb.  */
1189                                                              return 932;
1190                                                            }
1191                                                          else
1192                                                            {
1193                                                              /* 33222222222211111111110000000000
1194                                                                 10987654321098765432109876543210
1195                                                                 xxxxxxxxxx000011xxxxx1xx00011110
1196                                                                 ldaprh.  */
1197                                                              return 933;
1198                                                            }
1199                                                        }
1200                                                      else
1201                                                        {
1202                                                          /* 33222222222211111111110000000000
1203                                                             10987654321098765432109876543210
1204                                                             xxxxxxxxxx000011xxxxx1xx000111x1
1205                                                             ldapr.  */
1206                                                          return 934;
1207                                                        }
1208                                                    }
1209                                                }
1210                                            }
1211                                          else
1212                                            {
1213                                              if (((word >> 14) & 0x1) == 0)
1214                                                {
1215                                                  if (((word >> 22) & 0x1) == 0)
1216                                                    {
1217                                                      if (((word >> 23) & 0x1) == 0)
1218                                                        {
1219                                                          if (((word >> 31) & 0x1) == 0)
1220                                                            {
1221                                                              if (((word >> 30) & 0x1) == 0)
1222                                                                {
1223                                                                  /* 33222222222211111111110000000000
1224                                                                     10987654321098765432109876543210
1225                                                                     xxxxxxxxxx00010xxxxxx10000011100
1226                                                                     ldeorb.  */
1227                                                                  return 1030;
1228                                                                }
1229                                                              else
1230                                                                {
1231                                                                  /* 33222222222211111111110000000000
1232                                                                     10987654321098765432109876543210
1233                                                                     xxxxxxxxxx00010xxxxxx10000011110
1234                                                                     ldeorh.  */
1235                                                                  return 1031;
1236                                                                }
1237                                                            }
1238                                                          else
1239                                                            {
1240                                                              /* 33222222222211111111110000000000
1241                                                                 10987654321098765432109876543210
1242                                                                 xxxxxxxxxx00010xxxxxx100000111x1
1243                                                                 ldeor.  */
1244                                                              return 1032;
1245                                                            }
1246                                                        }
1247                                                      else
1248                                                        {
1249                                                          if (((word >> 31) & 0x1) == 0)
1250                                                            {
1251                                                              if (((word >> 30) & 0x1) == 0)
1252                                                                {
1253                                                                  /* 33222222222211111111110000000000
1254                                                                     10987654321098765432109876543210
1255                                                                     xxxxxxxxxx00010xxxxxx10100011100
1256                                                                     ldeorab.  */
1257                                                                  return 1033;
1258                                                                }
1259                                                              else
1260                                                                {
1261                                                                  /* 33222222222211111111110000000000
1262                                                                     10987654321098765432109876543210
1263                                                                     xxxxxxxxxx00010xxxxxx10100011110
1264                                                                     ldeorah.  */
1265                                                                  return 1036;
1266                                                                }
1267                                                            }
1268                                                          else
1269                                                            {
1270                                                              /* 33222222222211111111110000000000
1271                                                                 10987654321098765432109876543210
1272                                                                 xxxxxxxxxx00010xxxxxx101000111x1
1273                                                                 ldeora.  */
1274                                                              return 1039;
1275                                                            }
1276                                                        }
1277                                                    }
1278                                                  else
1279                                                    {
1280                                                      if (((word >> 23) & 0x1) == 0)
1281                                                        {
1282                                                          if (((word >> 31) & 0x1) == 0)
1283                                                            {
1284                                                              if (((word >> 30) & 0x1) == 0)
1285                                                                {
1286                                                                  /* 33222222222211111111110000000000
1287                                                                     10987654321098765432109876543210
1288                                                                     xxxxxxxxxx00010xxxxxx11000011100
1289                                                                     ldeorlb.  */
1290                                                                  return 1034;
1291                                                                }
1292                                                              else
1293                                                                {
1294                                                                  /* 33222222222211111111110000000000
1295                                                                     10987654321098765432109876543210
1296                                                                     xxxxxxxxxx00010xxxxxx11000011110
1297                                                                     ldeorlh.  */
1298                                                                  return 1037;
1299                                                                }
1300                                                            }
1301                                                          else
1302                                                            {
1303                                                              /* 33222222222211111111110000000000
1304                                                                 10987654321098765432109876543210
1305                                                                 xxxxxxxxxx00010xxxxxx110000111x1
1306                                                                 ldeorl.  */
1307                                                              return 1040;
1308                                                            }
1309                                                        }
1310                                                      else
1311                                                        {
1312                                                          if (((word >> 31) & 0x1) == 0)
1313                                                            {
1314                                                              if (((word >> 30) & 0x1) == 0)
1315                                                                {
1316                                                                  /* 33222222222211111111110000000000
1317                                                                     10987654321098765432109876543210
1318                                                                     xxxxxxxxxx00010xxxxxx11100011100
1319                                                                     ldeoralb.  */
1320                                                                  return 1035;
1321                                                                }
1322                                                              else
1323                                                                {
1324                                                                  /* 33222222222211111111110000000000
1325                                                                     10987654321098765432109876543210
1326                                                                     xxxxxxxxxx00010xxxxxx11100011110
1327                                                                     ldeoralh.  */
1328                                                                  return 1038;
1329                                                                }
1330                                                            }
1331                                                          else
1332                                                            {
1333                                                              /* 33222222222211111111110000000000
1334                                                                 10987654321098765432109876543210
1335                                                                 xxxxxxxxxx00010xxxxxx111000111x1
1336                                                                 ldeoral.  */
1337                                                              return 1041;
1338                                                            }
1339                                                        }
1340                                                    }
1341                                                }
1342                                              else
1343                                                {
1344                                                  if (((word >> 22) & 0x1) == 0)
1345                                                    {
1346                                                      if (((word >> 23) & 0x1) == 0)
1347                                                        {
1348                                                          if (((word >> 31) & 0x1) == 0)
1349                                                            {
1350                                                              if (((word >> 30) & 0x1) == 0)
1351                                                                {
1352                                                                  /* 33222222222211111111110000000000
1353                                                                     10987654321098765432109876543210
1354                                                                     xxxxxxxxxx00011xxxxxx10000011100
1355                                                                     ldumaxb.  */
1356                                                                  return 1078;
1357                                                                }
1358                                                              else
1359                                                                {
1360                                                                  /* 33222222222211111111110000000000
1361                                                                     10987654321098765432109876543210
1362                                                                     xxxxxxxxxx00011xxxxxx10000011110
1363                                                                     ldumaxh.  */
1364                                                                  return 1079;
1365                                                                }
1366                                                            }
1367                                                          else
1368                                                            {
1369                                                              /* 33222222222211111111110000000000
1370                                                                 10987654321098765432109876543210
1371                                                                 xxxxxxxxxx00011xxxxxx100000111x1
1372                                                                 ldumax.  */
1373                                                              return 1080;
1374                                                            }
1375                                                        }
1376                                                      else
1377                                                        {
1378                                                          if (((word >> 31) & 0x1) == 0)
1379                                                            {
1380                                                              if (((word >> 30) & 0x1) == 0)
1381                                                                {
1382                                                                  /* 33222222222211111111110000000000
1383                                                                     10987654321098765432109876543210
1384                                                                     xxxxxxxxxx00011xxxxxx10100011100
1385                                                                     ldumaxab.  */
1386                                                                  return 1081;
1387                                                                }
1388                                                              else
1389                                                                {
1390                                                                  /* 33222222222211111111110000000000
1391                                                                     10987654321098765432109876543210
1392                                                                     xxxxxxxxxx00011xxxxxx10100011110
1393                                                                     ldumaxah.  */
1394                                                                  return 1084;
1395                                                                }
1396                                                            }
1397                                                          else
1398                                                            {
1399                                                              /* 33222222222211111111110000000000
1400                                                                 10987654321098765432109876543210
1401                                                                 xxxxxxxxxx00011xxxxxx101000111x1
1402                                                                 ldumaxa.  */
1403                                                              return 1087;
1404                                                            }
1405                                                        }
1406                                                    }
1407                                                  else
1408                                                    {
1409                                                      if (((word >> 23) & 0x1) == 0)
1410                                                        {
1411                                                          if (((word >> 31) & 0x1) == 0)
1412                                                            {
1413                                                              if (((word >> 30) & 0x1) == 0)
1414                                                                {
1415                                                                  /* 33222222222211111111110000000000
1416                                                                     10987654321098765432109876543210
1417                                                                     xxxxxxxxxx00011xxxxxx11000011100
1418                                                                     ldumaxlb.  */
1419                                                                  return 1082;
1420                                                                }
1421                                                              else
1422                                                                {
1423                                                                  /* 33222222222211111111110000000000
1424                                                                     10987654321098765432109876543210
1425                                                                     xxxxxxxxxx00011xxxxxx11000011110
1426                                                                     ldumaxlh.  */
1427                                                                  return 1085;
1428                                                                }
1429                                                            }
1430                                                          else
1431                                                            {
1432                                                              /* 33222222222211111111110000000000
1433                                                                 10987654321098765432109876543210
1434                                                                 xxxxxxxxxx00011xxxxxx110000111x1
1435                                                                 ldumaxl.  */
1436                                                              return 1088;
1437                                                            }
1438                                                        }
1439                                                      else
1440                                                        {
1441                                                          if (((word >> 31) & 0x1) == 0)
1442                                                            {
1443                                                              if (((word >> 30) & 0x1) == 0)
1444                                                                {
1445                                                                  /* 33222222222211111111110000000000
1446                                                                     10987654321098765432109876543210
1447                                                                     xxxxxxxxxx00011xxxxxx11100011100
1448                                                                     ldumaxalb.  */
1449                                                                  return 1083;
1450                                                                }
1451                                                              else
1452                                                                {
1453                                                                  /* 33222222222211111111110000000000
1454                                                                     10987654321098765432109876543210
1455                                                                     xxxxxxxxxx00011xxxxxx11100011110
1456                                                                     ldumaxalh.  */
1457                                                                  return 1086;
1458                                                                }
1459                                                            }
1460                                                          else
1461                                                            {
1462                                                              /* 33222222222211111111110000000000
1463                                                                 10987654321098765432109876543210
1464                                                                 xxxxxxxxxx00011xxxxxx111000111x1
1465                                                                 ldumaxal.  */
1466                                                              return 1089;
1467                                                            }
1468                                                        }
1469                                                    }
1470                                                }
1471                                            }
1472                                        }
1473                                      else
1474                                        {
1475                                          if (((word >> 13) & 0x1) == 0)
1476                                            {
1477                                              if (((word >> 14) & 0x1) == 0)
1478                                                {
1479                                                  if (((word >> 22) & 0x1) == 0)
1480                                                    {
1481                                                      if (((word >> 23) & 0x1) == 0)
1482                                                        {
1483                                                          if (((word >> 31) & 0x1) == 0)
1484                                                            {
1485                                                              if (((word >> 30) & 0x1) == 0)
1486                                                                {
1487                                                                  /* 33222222222211111111110000000000
1488                                                                     10987654321098765432109876543210
1489                                                                     xxxxxxxxxx00100xxxxxx10000011100
1490                                                                     ldclrb.  */
1491                                                                  return 1018;
1492                                                                }
1493                                                              else
1494                                                                {
1495                                                                  /* 33222222222211111111110000000000
1496                                                                     10987654321098765432109876543210
1497                                                                     xxxxxxxxxx00100xxxxxx10000011110
1498                                                                     ldclrh.  */
1499                                                                  return 1019;
1500                                                                }
1501                                                            }
1502                                                          else
1503                                                            {
1504                                                              /* 33222222222211111111110000000000
1505                                                                 10987654321098765432109876543210
1506                                                                 xxxxxxxxxx00100xxxxxx100000111x1
1507                                                                 ldclr.  */
1508                                                              return 1020;
1509                                                            }
1510                                                        }
1511                                                      else
1512                                                        {
1513                                                          if (((word >> 31) & 0x1) == 0)
1514                                                            {
1515                                                              if (((word >> 30) & 0x1) == 0)
1516                                                                {
1517                                                                  /* 33222222222211111111110000000000
1518                                                                     10987654321098765432109876543210
1519                                                                     xxxxxxxxxx00100xxxxxx10100011100
1520                                                                     ldclrab.  */
1521                                                                  return 1021;
1522                                                                }
1523                                                              else
1524                                                                {
1525                                                                  /* 33222222222211111111110000000000
1526                                                                     10987654321098765432109876543210
1527                                                                     xxxxxxxxxx00100xxxxxx10100011110
1528                                                                     ldclrah.  */
1529                                                                  return 1024;
1530                                                                }
1531                                                            }
1532                                                          else
1533                                                            {
1534                                                              /* 33222222222211111111110000000000
1535                                                                 10987654321098765432109876543210
1536                                                                 xxxxxxxxxx00100xxxxxx101000111x1
1537                                                                 ldclra.  */
1538                                                              return 1027;
1539                                                            }
1540                                                        }
1541                                                    }
1542                                                  else
1543                                                    {
1544                                                      if (((word >> 23) & 0x1) == 0)
1545                                                        {
1546                                                          if (((word >> 31) & 0x1) == 0)
1547                                                            {
1548                                                              if (((word >> 30) & 0x1) == 0)
1549                                                                {
1550                                                                  /* 33222222222211111111110000000000
1551                                                                     10987654321098765432109876543210
1552                                                                     xxxxxxxxxx00100xxxxxx11000011100
1553                                                                     ldclrlb.  */
1554                                                                  return 1022;
1555                                                                }
1556                                                              else
1557                                                                {
1558                                                                  /* 33222222222211111111110000000000
1559                                                                     10987654321098765432109876543210
1560                                                                     xxxxxxxxxx00100xxxxxx11000011110
1561                                                                     ldclrlh.  */
1562                                                                  return 1025;
1563                                                                }
1564                                                            }
1565                                                          else
1566                                                            {
1567                                                              /* 33222222222211111111110000000000
1568                                                                 10987654321098765432109876543210
1569                                                                 xxxxxxxxxx00100xxxxxx110000111x1
1570                                                                 ldclrl.  */
1571                                                              return 1028;
1572                                                            }
1573                                                        }
1574                                                      else
1575                                                        {
1576                                                          if (((word >> 31) & 0x1) == 0)
1577                                                            {
1578                                                              if (((word >> 30) & 0x1) == 0)
1579                                                                {
1580                                                                  /* 33222222222211111111110000000000
1581                                                                     10987654321098765432109876543210
1582                                                                     xxxxxxxxxx00100xxxxxx11100011100
1583                                                                     ldclralb.  */
1584                                                                  return 1023;
1585                                                                }
1586                                                              else
1587                                                                {
1588                                                                  /* 33222222222211111111110000000000
1589                                                                     10987654321098765432109876543210
1590                                                                     xxxxxxxxxx00100xxxxxx11100011110
1591                                                                     ldclralh.  */
1592                                                                  return 1026;
1593                                                                }
1594                                                            }
1595                                                          else
1596                                                            {
1597                                                              /* 33222222222211111111110000000000
1598                                                                 10987654321098765432109876543210
1599                                                                 xxxxxxxxxx00100xxxxxx111000111x1
1600                                                                 ldclral.  */
1601                                                              return 1029;
1602                                                            }
1603                                                        }
1604                                                    }
1605                                                }
1606                                              else
1607                                                {
1608                                                  if (((word >> 22) & 0x1) == 0)
1609                                                    {
1610                                                      if (((word >> 23) & 0x1) == 0)
1611                                                        {
1612                                                          if (((word >> 31) & 0x1) == 0)
1613                                                            {
1614                                                              if (((word >> 30) & 0x1) == 0)
1615                                                                {
1616                                                                  /* 33222222222211111111110000000000
1617                                                                     10987654321098765432109876543210
1618                                                                     xxxxxxxxxx00101xxxxxx10000011100
1619                                                                     ldsminb.  */
1620                                                                  return 1066;
1621                                                                }
1622                                                              else
1623                                                                {
1624                                                                  /* 33222222222211111111110000000000
1625                                                                     10987654321098765432109876543210
1626                                                                     xxxxxxxxxx00101xxxxxx10000011110
1627                                                                     ldsminh.  */
1628                                                                  return 1067;
1629                                                                }
1630                                                            }
1631                                                          else
1632                                                            {
1633                                                              /* 33222222222211111111110000000000
1634                                                                 10987654321098765432109876543210
1635                                                                 xxxxxxxxxx00101xxxxxx100000111x1
1636                                                                 ldsmin.  */
1637                                                              return 1068;
1638                                                            }
1639                                                        }
1640                                                      else
1641                                                        {
1642                                                          if (((word >> 31) & 0x1) == 0)
1643                                                            {
1644                                                              if (((word >> 30) & 0x1) == 0)
1645                                                                {
1646                                                                  /* 33222222222211111111110000000000
1647                                                                     10987654321098765432109876543210
1648                                                                     xxxxxxxxxx00101xxxxxx10100011100
1649                                                                     ldsminab.  */
1650                                                                  return 1069;
1651                                                                }
1652                                                              else
1653                                                                {
1654                                                                  /* 33222222222211111111110000000000
1655                                                                     10987654321098765432109876543210
1656                                                                     xxxxxxxxxx00101xxxxxx10100011110
1657                                                                     ldsminah.  */
1658                                                                  return 1072;
1659                                                                }
1660                                                            }
1661                                                          else
1662                                                            {
1663                                                              /* 33222222222211111111110000000000
1664                                                                 10987654321098765432109876543210
1665                                                                 xxxxxxxxxx00101xxxxxx101000111x1
1666                                                                 ldsmina.  */
1667                                                              return 1075;
1668                                                            }
1669                                                        }
1670                                                    }
1671                                                  else
1672                                                    {
1673                                                      if (((word >> 23) & 0x1) == 0)
1674                                                        {
1675                                                          if (((word >> 31) & 0x1) == 0)
1676                                                            {
1677                                                              if (((word >> 30) & 0x1) == 0)
1678                                                                {
1679                                                                  /* 33222222222211111111110000000000
1680                                                                     10987654321098765432109876543210
1681                                                                     xxxxxxxxxx00101xxxxxx11000011100
1682                                                                     ldsminlb.  */
1683                                                                  return 1070;
1684                                                                }
1685                                                              else
1686                                                                {
1687                                                                  /* 33222222222211111111110000000000
1688                                                                     10987654321098765432109876543210
1689                                                                     xxxxxxxxxx00101xxxxxx11000011110
1690                                                                     ldsminlh.  */
1691                                                                  return 1073;
1692                                                                }
1693                                                            }
1694                                                          else
1695                                                            {
1696                                                              /* 33222222222211111111110000000000
1697                                                                 10987654321098765432109876543210
1698                                                                 xxxxxxxxxx00101xxxxxx110000111x1
1699                                                                 ldsminl.  */
1700                                                              return 1076;
1701                                                            }
1702                                                        }
1703                                                      else
1704                                                        {
1705                                                          if (((word >> 31) & 0x1) == 0)
1706                                                            {
1707                                                              if (((word >> 30) & 0x1) == 0)
1708                                                                {
1709                                                                  /* 33222222222211111111110000000000
1710                                                                     10987654321098765432109876543210
1711                                                                     xxxxxxxxxx00101xxxxxx11100011100
1712                                                                     ldsminalb.  */
1713                                                                  return 1071;
1714                                                                }
1715                                                              else
1716                                                                {
1717                                                                  /* 33222222222211111111110000000000
1718                                                                     10987654321098765432109876543210
1719                                                                     xxxxxxxxxx00101xxxxxx11100011110
1720                                                                     ldsminalh.  */
1721                                                                  return 1074;
1722                                                                }
1723                                                            }
1724                                                          else
1725                                                            {
1726                                                              /* 33222222222211111111110000000000
1727                                                                 10987654321098765432109876543210
1728                                                                 xxxxxxxxxx00101xxxxxx111000111x1
1729                                                                 ldsminal.  */
1730                                                              return 1077;
1731                                                            }
1732                                                        }
1733                                                    }
1734                                                }
1735                                            }
1736                                          else
1737                                            {
1738                                              if (((word >> 14) & 0x1) == 0)
1739                                                {
1740                                                  if (((word >> 22) & 0x1) == 0)
1741                                                    {
1742                                                      if (((word >> 23) & 0x1) == 0)
1743                                                        {
1744                                                          if (((word >> 31) & 0x1) == 0)
1745                                                            {
1746                                                              if (((word >> 30) & 0x1) == 0)
1747                                                                {
1748                                                                  /* 33222222222211111111110000000000
1749                                                                     10987654321098765432109876543210
1750                                                                     xxxxxxxxxx00110xxxxxx10000011100
1751                                                                     ldsetb.  */
1752                                                                  return 1042;
1753                                                                }
1754                                                              else
1755                                                                {
1756                                                                  /* 33222222222211111111110000000000
1757                                                                     10987654321098765432109876543210
1758                                                                     xxxxxxxxxx00110xxxxxx10000011110
1759                                                                     ldseth.  */
1760                                                                  return 1043;
1761                                                                }
1762                                                            }
1763                                                          else
1764                                                            {
1765                                                              /* 33222222222211111111110000000000
1766                                                                 10987654321098765432109876543210
1767                                                                 xxxxxxxxxx00110xxxxxx100000111x1
1768                                                                 ldset.  */
1769                                                              return 1044;
1770                                                            }
1771                                                        }
1772                                                      else
1773                                                        {
1774                                                          if (((word >> 31) & 0x1) == 0)
1775                                                            {
1776                                                              if (((word >> 30) & 0x1) == 0)
1777                                                                {
1778                                                                  /* 33222222222211111111110000000000
1779                                                                     10987654321098765432109876543210
1780                                                                     xxxxxxxxxx00110xxxxxx10100011100
1781                                                                     ldsetab.  */
1782                                                                  return 1045;
1783                                                                }
1784                                                              else
1785                                                                {
1786                                                                  /* 33222222222211111111110000000000
1787                                                                     10987654321098765432109876543210
1788                                                                     xxxxxxxxxx00110xxxxxx10100011110
1789                                                                     ldsetah.  */
1790                                                                  return 1048;
1791                                                                }
1792                                                            }
1793                                                          else
1794                                                            {
1795                                                              /* 33222222222211111111110000000000
1796                                                                 10987654321098765432109876543210
1797                                                                 xxxxxxxxxx00110xxxxxx101000111x1
1798                                                                 ldseta.  */
1799                                                              return 1051;
1800                                                            }
1801                                                        }
1802                                                    }
1803                                                  else
1804                                                    {
1805                                                      if (((word >> 23) & 0x1) == 0)
1806                                                        {
1807                                                          if (((word >> 31) & 0x1) == 0)
1808                                                            {
1809                                                              if (((word >> 30) & 0x1) == 0)
1810                                                                {
1811                                                                  /* 33222222222211111111110000000000
1812                                                                     10987654321098765432109876543210
1813                                                                     xxxxxxxxxx00110xxxxxx11000011100
1814                                                                     ldsetlb.  */
1815                                                                  return 1046;
1816                                                                }
1817                                                              else
1818                                                                {
1819                                                                  /* 33222222222211111111110000000000
1820                                                                     10987654321098765432109876543210
1821                                                                     xxxxxxxxxx00110xxxxxx11000011110
1822                                                                     ldsetlh.  */
1823                                                                  return 1049;
1824                                                                }
1825                                                            }
1826                                                          else
1827                                                            {
1828                                                              /* 33222222222211111111110000000000
1829                                                                 10987654321098765432109876543210
1830                                                                 xxxxxxxxxx00110xxxxxx110000111x1
1831                                                                 ldsetl.  */
1832                                                              return 1052;
1833                                                            }
1834                                                        }
1835                                                      else
1836                                                        {
1837                                                          if (((word >> 31) & 0x1) == 0)
1838                                                            {
1839                                                              if (((word >> 30) & 0x1) == 0)
1840                                                                {
1841                                                                  /* 33222222222211111111110000000000
1842                                                                     10987654321098765432109876543210
1843                                                                     xxxxxxxxxx00110xxxxxx11100011100
1844                                                                     ldsetalb.  */
1845                                                                  return 1047;
1846                                                                }
1847                                                              else
1848                                                                {
1849                                                                  /* 33222222222211111111110000000000
1850                                                                     10987654321098765432109876543210
1851                                                                     xxxxxxxxxx00110xxxxxx11100011110
1852                                                                     ldsetalh.  */
1853                                                                  return 1050;
1854                                                                }
1855                                                            }
1856                                                          else
1857                                                            {
1858                                                              /* 33222222222211111111110000000000
1859                                                                 10987654321098765432109876543210
1860                                                                 xxxxxxxxxx00110xxxxxx111000111x1
1861                                                                 ldsetal.  */
1862                                                              return 1053;
1863                                                            }
1864                                                        }
1865                                                    }
1866                                                }
1867                                              else
1868                                                {
1869                                                  if (((word >> 22) & 0x1) == 0)
1870                                                    {
1871                                                      if (((word >> 23) & 0x1) == 0)
1872                                                        {
1873                                                          if (((word >> 31) & 0x1) == 0)
1874                                                            {
1875                                                              if (((word >> 30) & 0x1) == 0)
1876                                                                {
1877                                                                  /* 33222222222211111111110000000000
1878                                                                     10987654321098765432109876543210
1879                                                                     xxxxxxxxxx00111xxxxxx10000011100
1880                                                                     lduminb.  */
1881                                                                  return 1090;
1882                                                                }
1883                                                              else
1884                                                                {
1885                                                                  /* 33222222222211111111110000000000
1886                                                                     10987654321098765432109876543210
1887                                                                     xxxxxxxxxx00111xxxxxx10000011110
1888                                                                     lduminh.  */
1889                                                                  return 1091;
1890                                                                }
1891                                                            }
1892                                                          else
1893                                                            {
1894                                                              /* 33222222222211111111110000000000
1895                                                                 10987654321098765432109876543210
1896                                                                 xxxxxxxxxx00111xxxxxx100000111x1
1897                                                                 ldumin.  */
1898                                                              return 1092;
1899                                                            }
1900                                                        }
1901                                                      else
1902                                                        {
1903                                                          if (((word >> 31) & 0x1) == 0)
1904                                                            {
1905                                                              if (((word >> 30) & 0x1) == 0)
1906                                                                {
1907                                                                  /* 33222222222211111111110000000000
1908                                                                     10987654321098765432109876543210
1909                                                                     xxxxxxxxxx00111xxxxxx10100011100
1910                                                                     lduminab.  */
1911                                                                  return 1093;
1912                                                                }
1913                                                              else
1914                                                                {
1915                                                                  /* 33222222222211111111110000000000
1916                                                                     10987654321098765432109876543210
1917                                                                     xxxxxxxxxx00111xxxxxx10100011110
1918                                                                     lduminah.  */
1919                                                                  return 1096;
1920                                                                }
1921                                                            }
1922                                                          else
1923                                                            {
1924                                                              /* 33222222222211111111110000000000
1925                                                                 10987654321098765432109876543210
1926                                                                 xxxxxxxxxx00111xxxxxx101000111x1
1927                                                                 ldumina.  */
1928                                                              return 1099;
1929                                                            }
1930                                                        }
1931                                                    }
1932                                                  else
1933                                                    {
1934                                                      if (((word >> 23) & 0x1) == 0)
1935                                                        {
1936                                                          if (((word >> 31) & 0x1) == 0)
1937                                                            {
1938                                                              if (((word >> 30) & 0x1) == 0)
1939                                                                {
1940                                                                  /* 33222222222211111111110000000000
1941                                                                     10987654321098765432109876543210
1942                                                                     xxxxxxxxxx00111xxxxxx11000011100
1943                                                                     lduminlb.  */
1944                                                                  return 1094;
1945                                                                }
1946                                                              else
1947                                                                {
1948                                                                  /* 33222222222211111111110000000000
1949                                                                     10987654321098765432109876543210
1950                                                                     xxxxxxxxxx00111xxxxxx11000011110
1951                                                                     lduminlh.  */
1952                                                                  return 1097;
1953                                                                }
1954                                                            }
1955                                                          else
1956                                                            {
1957                                                              /* 33222222222211111111110000000000
1958                                                                 10987654321098765432109876543210
1959                                                                 xxxxxxxxxx00111xxxxxx110000111x1
1960                                                                 lduminl.  */
1961                                                              return 1100;
1962                                                            }
1963                                                        }
1964                                                      else
1965                                                        {
1966                                                          if (((word >> 31) & 0x1) == 0)
1967                                                            {
1968                                                              if (((word >> 30) & 0x1) == 0)
1969                                                                {
1970                                                                  /* 33222222222211111111110000000000
1971                                                                     10987654321098765432109876543210
1972                                                                     xxxxxxxxxx00111xxxxxx11100011100
1973                                                                     lduminalb.  */
1974                                                                  return 1095;
1975                                                                }
1976                                                              else
1977                                                                {
1978                                                                  /* 33222222222211111111110000000000
1979                                                                     10987654321098765432109876543210
1980                                                                     xxxxxxxxxx00111xxxxxx11100011110
1981                                                                     lduminalh.  */
1982                                                                  return 1098;
1983                                                                }
1984                                                            }
1985                                                          else
1986                                                            {
1987                                                              /* 33222222222211111111110000000000
1988                                                                 10987654321098765432109876543210
1989                                                                 xxxxxxxxxx00111xxxxxx111000111x1
1990                                                                 lduminal.  */
1991                                                              return 1101;
1992                                                            }
1993                                                        }
1994                                                    }
1995                                                }
1996                                            }
1997                                        }
1998                                    }
1999                                }
2000                              else
2001                                {
2002                                  if (((word >> 21) & 0x1) == 0)
2003                                    {
2004                                      if (((word >> 23) & 0x1) == 0)
2005                                        {
2006                                          if (((word >> 22) & 0x1) == 0)
2007                                            {
2008                                              if (((word >> 31) & 0x1) == 0)
2009                                                {
2010                                                  if (((word >> 30) & 0x1) == 0)
2011                                                    {
2012                                                      /* 33222222222211111111110000000000
2013                                                         10987654321098765432109876543210
2014                                                         xxxxxxxxxx01xxxxxxxxx00000011100
2015                                                         sttrb.  */
2016                                                      return 887;
2017                                                    }
2018                                                  else
2019                                                    {
2020                                                      /* 33222222222211111111110000000000
2021                                                         10987654321098765432109876543210
2022                                                         xxxxxxxxxx01xxxxxxxxx00000011110
2023                                                         sttrh.  */
2024                                                      return 890;
2025                                                    }
2026                                                }
2027                                              else
2028                                                {
2029                                                  /* 33222222222211111111110000000000
2030                                                     10987654321098765432109876543210
2031                                                     xxxxxxxxxx01xxxxxxxxx000000111x1
2032                                                     sttr.  */
2033                                                  return 893;
2034                                                }
2035                                            }
2036                                          else
2037                                            {
2038                                              if (((word >> 31) & 0x1) == 0)
2039                                                {
2040                                                  if (((word >> 30) & 0x1) == 0)
2041                                                    {
2042                                                      /* 33222222222211111111110000000000
2043                                                         10987654321098765432109876543210
2044                                                         xxxxxxxxxx01xxxxxxxxx01000011100
2045                                                         ldtrb.  */
2046                                                      return 888;
2047                                                    }
2048                                                  else
2049                                                    {
2050                                                      /* 33222222222211111111110000000000
2051                                                         10987654321098765432109876543210
2052                                                         xxxxxxxxxx01xxxxxxxxx01000011110
2053                                                         ldtrh.  */
2054                                                      return 891;
2055                                                    }
2056                                                }
2057                                              else
2058                                                {
2059                                                  /* 33222222222211111111110000000000
2060                                                     10987654321098765432109876543210
2061                                                     xxxxxxxxxx01xxxxxxxxx010000111x1
2062                                                     ldtr.  */
2063                                                  return 894;
2064                                                }
2065                                            }
2066                                        }
2067                                      else
2068                                        {
2069                                          if (((word >> 30) & 0x1) == 0)
2070                                            {
2071                                              if (((word >> 31) & 0x1) == 0)
2072                                                {
2073                                                  /* 33222222222211111111110000000000
2074                                                     10987654321098765432109876543210
2075                                                     xxxxxxxxxx01xxxxxxxxx0x100011100
2076                                                     ldtrsb.  */
2077                                                  return 889;
2078                                                }
2079                                              else
2080                                                {
2081                                                  /* 33222222222211111111110000000000
2082                                                     10987654321098765432109876543210
2083                                                     xxxxxxxxxx01xxxxxxxxx0x100011101
2084                                                     ldtrsw.  */
2085                                                  return 895;
2086                                                }
2087                                            }
2088                                          else
2089                                            {
2090                                              /* 33222222222211111111110000000000
2091                                                 10987654321098765432109876543210
2092                                                 xxxxxxxxxx01xxxxxxxxx0x10001111x
2093                                                 ldtrsh.  */
2094                                              return 892;
2095                                            }
2096                                        }
2097                                    }
2098                                  else
2099                                    {
2100                                      if (((word >> 23) & 0x1) == 0)
2101                                        {
2102                                          if (((word >> 22) & 0x1) == 0)
2103                                            {
2104                                              if (((word >> 31) & 0x1) == 0)
2105                                                {
2106                                                  if (((word >> 30) & 0x1) == 0)
2107                                                    {
2108                                                      /* 33222222222211111111110000000000
2109                                                         10987654321098765432109876543210
2110                                                         xxxxxxxxxx01xxxxxxxxx10000011100
2111                                                         strb.  */
2112                                                      return 875;
2113                                                    }
2114                                                  else
2115                                                    {
2116                                                      /* 33222222222211111111110000000000
2117                                                         10987654321098765432109876543210
2118                                                         xxxxxxxxxx01xxxxxxxxx10000011110
2119                                                         strh.  */
2120                                                      return 880;
2121                                                    }
2122                                                }
2123                                              else
2124                                                {
2125                                                  /* 33222222222211111111110000000000
2126                                                     10987654321098765432109876543210
2127                                                     xxxxxxxxxx01xxxxxxxxx100000111x1
2128                                                     str.  */
2129                                                  return 883;
2130                                                }
2131                                            }
2132                                          else
2133                                            {
2134                                              if (((word >> 31) & 0x1) == 0)
2135                                                {
2136                                                  if (((word >> 30) & 0x1) == 0)
2137                                                    {
2138                                                      /* 33222222222211111111110000000000
2139                                                         10987654321098765432109876543210
2140                                                         xxxxxxxxxx01xxxxxxxxx11000011100
2141                                                         ldrb.  */
2142                                                      return 876;
2143                                                    }
2144                                                  else
2145                                                    {
2146                                                      /* 33222222222211111111110000000000
2147                                                         10987654321098765432109876543210
2148                                                         xxxxxxxxxx01xxxxxxxxx11000011110
2149                                                         ldrh.  */
2150                                                      return 881;
2151                                                    }
2152                                                }
2153                                              else
2154                                                {
2155                                                  /* 33222222222211111111110000000000
2156                                                     10987654321098765432109876543210
2157                                                     xxxxxxxxxx01xxxxxxxxx110000111x1
2158                                                     ldr.  */
2159                                                  return 884;
2160                                                }
2161                                            }
2162                                        }
2163                                      else
2164                                        {
2165                                          if (((word >> 30) & 0x1) == 0)
2166                                            {
2167                                              if (((word >> 31) & 0x1) == 0)
2168                                                {
2169                                                  /* 33222222222211111111110000000000
2170                                                     10987654321098765432109876543210
2171                                                     xxxxxxxxxx01xxxxxxxxx1x100011100
2172                                                     ldrsb.  */
2173                                                  return 877;
2174                                                }
2175                                              else
2176                                                {
2177                                                  /* 33222222222211111111110000000000
2178                                                     10987654321098765432109876543210
2179                                                     xxxxxxxxxx01xxxxxxxxx1x100011101
2180                                                     ldrsw.  */
2181                                                  return 885;
2182                                                }
2183                                            }
2184                                          else
2185                                            {
2186                                              if (((word >> 31) & 0x1) == 0)
2187                                                {
2188                                                  /* 33222222222211111111110000000000
2189                                                     10987654321098765432109876543210
2190                                                     xxxxxxxxxx01xxxxxxxxx1x100011110
2191                                                     ldrsh.  */
2192                                                  return 882;
2193                                                }
2194                                              else
2195                                                {
2196                                                  /* 33222222222211111111110000000000
2197                                                     10987654321098765432109876543210
2198                                                     xxxxxxxxxx01xxxxxxxxx1x100011111
2199                                                     prfm.  */
2200                                                  return 886;
2201                                                }
2202                                            }
2203                                        }
2204                                    }
2205                                }
2206                            }
2207                          else
2208                            {
2209                              if (((word >> 21) & 0x1) == 0)
2210                                {
2211                                  if (((word >> 23) & 0x1) == 0)
2212                                    {
2213                                      if (((word >> 22) & 0x1) == 0)
2214                                        {
2215                                          if (((word >> 31) & 0x1) == 0)
2216                                            {
2217                                              if (((word >> 30) & 0x1) == 0)
2218                                                {
2219                                                  /* 33222222222211111111110000000000
2220                                                     10987654321098765432109876543210
2221                                                     xxxxxxxxxx1xxxxxxxxxx00000011100
2222                                                     strb.  */
2223                                                  return 852;
2224                                                }
2225                                              else
2226                                                {
2227                                                  /* 33222222222211111111110000000000
2228                                                     10987654321098765432109876543210
2229                                                     xxxxxxxxxx1xxxxxxxxxx00000011110
2230                                                     strh.  */
2231                                                  return 857;
2232                                                }
2233                                            }
2234                                          else
2235                                            {
2236                                              /* 33222222222211111111110000000000
2237                                                 10987654321098765432109876543210
2238                                                 xxxxxxxxxx1xxxxxxxxxx000000111x1
2239                                                 str.  */
2240                                              return 860;
2241                                            }
2242                                        }
2243                                      else
2244                                        {
2245                                          if (((word >> 31) & 0x1) == 0)
2246                                            {
2247                                              if (((word >> 30) & 0x1) == 0)
2248                                                {
2249                                                  /* 33222222222211111111110000000000
2250                                                     10987654321098765432109876543210
2251                                                     xxxxxxxxxx1xxxxxxxxxx01000011100
2252                                                     ldrb.  */
2253                                                  return 853;
2254                                                }
2255                                              else
2256                                                {
2257                                                  /* 33222222222211111111110000000000
2258                                                     10987654321098765432109876543210
2259                                                     xxxxxxxxxx1xxxxxxxxxx01000011110
2260                                                     ldrh.  */
2261                                                  return 858;
2262                                                }
2263                                            }
2264                                          else
2265                                            {
2266                                              /* 33222222222211111111110000000000
2267                                                 10987654321098765432109876543210
2268                                                 xxxxxxxxxx1xxxxxxxxxx010000111x1
2269                                                 ldr.  */
2270                                              return 861;
2271                                            }
2272                                        }
2273                                    }
2274                                  else
2275                                    {
2276                                      if (((word >> 30) & 0x1) == 0)
2277                                        {
2278                                          if (((word >> 31) & 0x1) == 0)
2279                                            {
2280                                              /* 33222222222211111111110000000000
2281                                                 10987654321098765432109876543210
2282                                                 xxxxxxxxxx1xxxxxxxxxx0x100011100
2283                                                 ldrsb.  */
2284                                              return 854;
2285                                            }
2286                                          else
2287                                            {
2288                                              /* 33222222222211111111110000000000
2289                                                 10987654321098765432109876543210
2290                                                 xxxxxxxxxx1xxxxxxxxxx0x100011101
2291                                                 ldrsw.  */
2292                                              return 862;
2293                                            }
2294                                        }
2295                                      else
2296                                        {
2297                                          /* 33222222222211111111110000000000
2298                                             10987654321098765432109876543210
2299                                             xxxxxxxxxx1xxxxxxxxxx0x10001111x
2300                                             ldrsh.  */
2301                                          return 859;
2302                                        }
2303                                    }
2304                                }
2305                              else
2306                                {
2307                                  if (((word >> 23) & 0x1) == 0)
2308                                    {
2309                                      /* 33222222222211111111110000000000
2310                                         10987654321098765432109876543210
2311                                         xxxxxxxxxx1xxxxxxxxxx1x0000111xx
2312                                         ldraa.  */
2313                                      return 908;
2314                                    }
2315                                  else
2316                                    {
2317                                      /* 33222222222211111111110000000000
2318                                         10987654321098765432109876543210
2319                                         xxxxxxxxxx1xxxxxxxxxx1x1000111xx
2320                                         ldrab.  */
2321                                      return 909;
2322                                    }
2323                                }
2324                            }
2325                        }
2326                    }
2327                  else
2328                    {
2329                      if (((word >> 23) & 0x1) == 0)
2330                        {
2331                          if (((word >> 22) & 0x1) == 0)
2332                            {
2333                              if (((word >> 31) & 0x1) == 0)
2334                                {
2335                                  if (((word >> 30) & 0x1) == 0)
2336                                    {
2337                                      /* 33222222222211111111110000000000
2338                                         10987654321098765432109876543210
2339                                         xxxxxxxxxxxxxxxxxxxxxx0010011x00
2340                                         strb.  */
2341                                      return 863;
2342                                    }
2343                                  else
2344                                    {
2345                                      /* 33222222222211111111110000000000
2346                                         10987654321098765432109876543210
2347                                         xxxxxxxxxxxxxxxxxxxxxx0010011x10
2348                                         strh.  */
2349                                      return 868;
2350                                    }
2351                                }
2352                              else
2353                                {
2354                                  /* 33222222222211111111110000000000
2355                                     10987654321098765432109876543210
2356                                     xxxxxxxxxxxxxxxxxxxxxx0010011xx1
2357                                     str.  */
2358                                  return 871;
2359                                }
2360                            }
2361                          else
2362                            {
2363                              if (((word >> 31) & 0x1) == 0)
2364                                {
2365                                  if (((word >> 30) & 0x1) == 0)
2366                                    {
2367                                      /* 33222222222211111111110000000000
2368                                         10987654321098765432109876543210
2369                                         xxxxxxxxxxxxxxxxxxxxxx1010011x00
2370                                         ldrb.  */
2371                                      return 864;
2372                                    }
2373                                  else
2374                                    {
2375                                      /* 33222222222211111111110000000000
2376                                         10987654321098765432109876543210
2377                                         xxxxxxxxxxxxxxxxxxxxxx1010011x10
2378                                         ldrh.  */
2379                                      return 869;
2380                                    }
2381                                }
2382                              else
2383                                {
2384                                  /* 33222222222211111111110000000000
2385                                     10987654321098765432109876543210
2386                                     xxxxxxxxxxxxxxxxxxxxxx1010011xx1
2387                                     ldr.  */
2388                                  return 872;
2389                                }
2390                            }
2391                        }
2392                      else
2393                        {
2394                          if (((word >> 30) & 0x1) == 0)
2395                            {
2396                              if (((word >> 31) & 0x1) == 0)
2397                                {
2398                                  /* 33222222222211111111110000000000
2399                                     10987654321098765432109876543210
2400                                     xxxxxxxxxxxxxxxxxxxxxxx110011x00
2401                                     ldrsb.  */
2402                                  return 865;
2403                                }
2404                              else
2405                                {
2406                                  /* 33222222222211111111110000000000
2407                                     10987654321098765432109876543210
2408                                     xxxxxxxxxxxxxxxxxxxxxxx110011x01
2409                                     ldrsw.  */
2410                                  return 873;
2411                                }
2412                            }
2413                          else
2414                            {
2415                              if (((word >> 31) & 0x1) == 0)
2416                                {
2417                                  /* 33222222222211111111110000000000
2418                                     10987654321098765432109876543210
2419                                     xxxxxxxxxxxxxxxxxxxxxxx110011x10
2420                                     ldrsh.  */
2421                                  return 870;
2422                                }
2423                              else
2424                                {
2425                                  /* 33222222222211111111110000000000
2426                                     10987654321098765432109876543210
2427                                     xxxxxxxxxxxxxxxxxxxxxxx110011x11
2428                                     prfm.  */
2429                                  return 874;
2430                                }
2431                            }
2432                        }
2433                    }
2434                }
2435            }
2436        }
2437      else
2438        {
2439          if (((word >> 24) & 0x1) == 0)
2440            {
2441              if (((word >> 27) & 0x1) == 0)
2442                {
2443                  if (((word >> 23) & 0x1) == 0)
2444                    {
2445                      if (((word >> 29) & 0x1) == 0)
2446                        {
2447                          if (((word >> 30) & 0x1) == 0)
2448                            {
2449                              /* 33222222222211111111110000000000
2450                                 10987654321098765432109876543210
2451                                 xxxxxxxxxxxxxxxxxxxxxxx00100x00x
2452                                 and.  */
2453                              return 959;
2454                            }
2455                          else
2456                            {
2457                              /* 33222222222211111111110000000000
2458                                 10987654321098765432109876543210
2459                                 xxxxxxxxxxxxxxxxxxxxxxx00100x01x
2460                                 eor.  */
2461                              return 963;
2462                            }
2463                        }
2464                      else
2465                        {
2466                          if (((word >> 30) & 0x1) == 0)
2467                            {
2468                              /* 33222222222211111111110000000000
2469                                 10987654321098765432109876543210
2470                                 xxxxxxxxxxxxxxxxxxxxxxx00100x10x
2471                                 orr.  */
2472                              return 961;
2473                            }
2474                          else
2475                            {
2476                              /* 33222222222211111111110000000000
2477                                 10987654321098765432109876543210
2478                                 xxxxxxxxxxxxxxxxxxxxxxx00100x11x
2479                                 ands.  */
2480                              return 964;
2481                            }
2482                        }
2483                    }
2484                  else
2485                    {
2486                      if (((word >> 29) & 0x1) == 0)
2487                        {
2488                          if (((word >> 30) & 0x1) == 0)
2489                            {
2490                              /* 33222222222211111111110000000000
2491                                 10987654321098765432109876543210
2492                                 xxxxxxxxxxxxxxxxxxxxxxx10100x00x
2493                                 movn.  */
2494                              return 1150;
2495                            }
2496                          else
2497                            {
2498                              /* 33222222222211111111110000000000
2499                                 10987654321098765432109876543210
2500                                 xxxxxxxxxxxxxxxxxxxxxxx10100x01x
2501                                 movz.  */
2502                              return 1152;
2503                            }
2504                        }
2505                      else
2506                        {
2507                          /* 33222222222211111111110000000000
2508                             10987654321098765432109876543210
2509                             xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
2510                             movk.  */
2511                          return 1154;
2512                        }
2513                    }
2514                }
2515              else
2516                {
2517                  if (((word >> 21) & 0x1) == 0)
2518                    {
2519                      if (((word >> 28) & 0x1) == 0)
2520                        {
2521                          if (((word >> 29) & 0x1) == 0)
2522                            {
2523                              if (((word >> 30) & 0x1) == 0)
2524                                {
2525                                  /* 33222222222211111111110000000000
2526                                     10987654321098765432109876543210
2527                                     xxxxxxxxxxxxxxxxxxxxx0xx0101000x
2528                                     and.  */
2529                                  return 966;
2530                                }
2531                              else
2532                                {
2533                                  /* 33222222222211111111110000000000
2534                                     10987654321098765432109876543210
2535                                     xxxxxxxxxxxxxxxxxxxxx0xx0101001x
2536                                     eor.  */
2537                                  return 973;
2538                                }
2539                            }
2540                          else
2541                            {
2542                              if (((word >> 30) & 0x1) == 0)
2543                                {
2544                                  /* 33222222222211111111110000000000
2545                                     10987654321098765432109876543210
2546                                     xxxxxxxxxxxxxxxxxxxxx0xx0101010x
2547                                     orr.  */
2548                                  return 968;
2549                                }
2550                              else
2551                                {
2552                                  /* 33222222222211111111110000000000
2553                                     10987654321098765432109876543210
2554                                     xxxxxxxxxxxxxxxxxxxxx0xx0101011x
2555                                     ands.  */
2556                                  return 975;
2557                                }
2558                            }
2559                        }
2560                      else
2561                        {
2562                          if (((word >> 10) & 0x1) == 0)
2563                            {
2564                              if (((word >> 11) & 0x1) == 0)
2565                                {
2566                                  if (((word >> 22) & 0x1) == 0)
2567                                    {
2568                                      if (((word >> 23) & 0x1) == 0)
2569                                        {
2570                                          if (((word >> 29) & 0x1) == 0)
2571                                            {
2572                                              if (((word >> 30) & 0x1) == 0)
2573                                                {
2574                                                  /* 33222222222211111111110000000000
2575                                                     10987654321098765432109876543210
2576                                                     xxxxxxxxxx00xxxxxxxxx0000101100x
2577                                                     adc.  */
2578                                                  return 0;
2579                                                }
2580                                              else
2581                                                {
2582                                                  /* 33222222222211111111110000000000
2583                                                     10987654321098765432109876543210
2584                                                     xxxxxxxxxx00xxxxxxxxx0000101101x
2585                                                     sbc.  */
2586                                                  return 2;
2587                                                }
2588                                            }
2589                                          else
2590                                            {
2591                                              if (((word >> 30) & 0x1) == 0)
2592                                                {
2593                                                  /* 33222222222211111111110000000000
2594                                                     10987654321098765432109876543210
2595                                                     xxxxxxxxxx00xxxxxxxxx0000101110x
2596                                                     adcs.  */
2597                                                  return 1;
2598                                                }
2599                                              else
2600                                                {
2601                                                  /* 33222222222211111111110000000000
2602                                                     10987654321098765432109876543210
2603                                                     xxxxxxxxxx00xxxxxxxxx0000101111x
2604                                                     sbcs.  */
2605                                                  return 4;
2606                                                }
2607                                            }
2608                                        }
2609                                      else
2610                                        {
2611                                          if (((word >> 30) & 0x1) == 0)
2612                                            {
2613                                              /* 33222222222211111111110000000000
2614                                                 10987654321098765432109876543210
2615                                                 xxxxxxxxxx00xxxxxxxxx00101011x0x
2616                                                 csel.  */
2617                                              return 656;
2618                                            }
2619                                          else
2620                                            {
2621                                              /* 33222222222211111111110000000000
2622                                                 10987654321098765432109876543210
2623                                                 xxxxxxxxxx00xxxxxxxxx00101011x1x
2624                                                 csinv.  */
2625                                              return 660;
2626                                            }
2627                                        }
2628                                    }
2629                                  else
2630                                    {
2631                                      if (((word >> 23) & 0x1) == 0)
2632                                        {
2633                                          if (((word >> 30) & 0x1) == 0)
2634                                            {
2635                                              /* 33222222222211111111110000000000
2636                                                 10987654321098765432109876543210
2637                                                 xxxxxxxxxx00xxxxxxxxx01001011x0x
2638                                                 ccmn.  */
2639                                              return 654;
2640                                            }
2641                                          else
2642                                            {
2643                                              /* 33222222222211111111110000000000
2644                                                 10987654321098765432109876543210
2645                                                 xxxxxxxxxx00xxxxxxxxx01001011x1x
2646                                                 ccmp.  */
2647                                              return 655;
2648                                            }
2649                                        }
2650                                      else
2651                                        {
2652                                          if (((word >> 12) & 0x1) == 0)
2653                                            {
2654                                              if (((word >> 13) & 0x1) == 0)
2655                                                {
2656                                                  if (((word >> 14) & 0x1) == 0)
2657                                                    {
2658                                                      if (((word >> 16) & 0x1) == 0)
2659                                                        {
2660                                                          /* 33222222222211111111110000000000
2661                                                             10987654321098765432109876543210
2662                                                             xxxxxxxxxx00000x0xxxx01101011xxx
2663                                                             rbit.  */
2664                                                          return 679;
2665                                                        }
2666                                                      else
2667                                                        {
2668                                                          /* 33222222222211111111110000000000
2669                                                             10987654321098765432109876543210
2670                                                             xxxxxxxxxx00000x1xxxx01101011xxx
2671                                                             pacia.  */
2672                                                          return 687;
2673                                                        }
2674                                                    }
2675                                                  else
2676                                                    {
2677                                                      if (((word >> 30) & 0x1) == 0)
2678                                                        {
2679                                                          /* 33222222222211111111110000000000
2680                                                             10987654321098765432109876543210
2681                                                             xxxxxxxxxx00001xxxxxx01101011x0x
2682                                                             crc32b.  */
2683                                                          return 716;
2684                                                        }
2685                                                      else
2686                                                        {
2687                                                          /* 33222222222211111111110000000000
2688                                                             10987654321098765432109876543210
2689                                                             xxxxxxxxxx00001xxxxxx01101011x1x
2690                                                             xpaci.  */
2691                                                          return 703;
2692                                                        }
2693                                                    }
2694                                                }
2695                                              else
2696                                                {
2697                                                  if (((word >> 30) & 0x1) == 0)
2698                                                    {
2699                                                      /* 33222222222211111111110000000000
2700                                                         10987654321098765432109876543210
2701                                                         xxxxxxxxxx0001xxxxxxx01101011x0x
2702                                                         lslv.  */
2703                                                      return 707;
2704                                                    }
2705                                                  else
2706                                                    {
2707                                                      /* 33222222222211111111110000000000
2708                                                         10987654321098765432109876543210
2709                                                         xxxxxxxxxx0001xxxxxxx01101011x1x
2710                                                         paciza.  */
2711                                                      return 695;
2712                                                    }
2713                                                }
2714                                            }
2715                                          else
2716                                            {
2717                                              if (((word >> 13) & 0x1) == 0)
2718                                                {
2719                                                  if (((word >> 14) & 0x1) == 0)
2720                                                    {
2721                                                      if (((word >> 16) & 0x1) == 0)
2722                                                        {
2723                                                          /* 33222222222211111111110000000000
2724                                                             10987654321098765432109876543210
2725                                                             xxxxxxxxxx00100x0xxxx01101011xxx
2726                                                             clz.  */
2727                                                          return 684;
2728                                                        }
2729                                                      else
2730                                                        {
2731                                                          /* 33222222222211111111110000000000
2732                                                             10987654321098765432109876543210
2733                                                             xxxxxxxxxx00100x1xxxx01101011xxx
2734                                                             autia.  */
2735                                                          return 691;
2736                                                        }
2737                                                    }
2738                                                  else
2739                                                    {
2740                                                      /* 33222222222211111111110000000000
2741                                                         10987654321098765432109876543210
2742                                                         xxxxxxxxxx00101xxxxxx01101011xxx
2743                                                         crc32cb.  */
2744                                                      return 720;
2745                                                    }
2746                                                }
2747                                              else
2748                                                {
2749                                                  if (((word >> 30) & 0x1) == 0)
2750                                                    {
2751                                                      /* 33222222222211111111110000000000
2752                                                         10987654321098765432109876543210
2753                                                         xxxxxxxxxx0011xxxxxxx01101011x0x
2754                                                         pacga.  */
2755                                                      return 715;
2756                                                    }
2757                                                  else
2758                                                    {
2759                                                      /* 33222222222211111111110000000000
2760                                                         10987654321098765432109876543210
2761                                                         xxxxxxxxxx0011xxxxxxx01101011x1x
2762                                                         autiza.  */
2763                                                      return 699;
2764                                                    }
2765                                                }
2766                                            }
2767                                        }
2768                                    }
2769                                }
2770                              else
2771                                {
2772                                  if (((word >> 23) & 0x1) == 0)
2773                                    {
2774                                      if (((word >> 30) & 0x1) == 0)
2775                                        {
2776                                          /* 33222222222211111111110000000000
2777                                             10987654321098765432109876543210
2778                                             xxxxxxxxxx01xxxxxxxxx0x001011x0x
2779                                             ccmn.  */
2780                                          return 652;
2781                                        }
2782                                      else
2783                                        {
2784                                          /* 33222222222211111111110000000000
2785                                             10987654321098765432109876543210
2786                                             xxxxxxxxxx01xxxxxxxxx0x001011x1x
2787                                             ccmp.  */
2788                                          return 653;
2789                                        }
2790                                    }
2791                                  else
2792                                    {
2793                                      if (((word >> 12) & 0x1) == 0)
2794                                        {
2795                                          if (((word >> 13) & 0x1) == 0)
2796                                            {
2797                                              if (((word >> 14) & 0x1) == 0)
2798                                                {
2799                                                  if (((word >> 30) & 0x1) == 0)
2800                                                    {
2801                                                      /* 33222222222211111111110000000000
2802                                                         10987654321098765432109876543210
2803                                                         xxxxxxxxxx01000xxxxxx0x101011x0x
2804                                                         udiv.  */
2805                                                      return 705;
2806                                                    }
2807                                                  else
2808                                                    {
2809                                                      if (((word >> 16) & 0x1) == 0)
2810                                                        {
2811                                                          if (((word >> 31) & 0x1) == 0)
2812                                                            {
2813                                                              /* 33222222222211111111110000000000
2814                                                                 10987654321098765432109876543210
2815                                                                 xxxxxxxxxx01000x0xxxx0x101011x10
2816                                                                 rev.  */
2817                                                              return 681;
2818                                                            }
2819                                                          else
2820                                                            {
2821                                                              /* 33222222222211111111110000000000
2822                                                                 10987654321098765432109876543210
2823                                                                 xxxxxxxxxx01000x0xxxx0x101011x11
2824                                                                 rev32.  */
2825                                                              return 686;
2826                                                            }
2827                                                        }
2828                                                      else
2829                                                        {
2830                                                          /* 33222222222211111111110000000000
2831                                                             10987654321098765432109876543210
2832                                                             xxxxxxxxxx01000x1xxxx0x101011x1x
2833                                                             pacda.  */
2834                                                          return 689;
2835                                                        }
2836                                                    }
2837                                                }
2838                                              else
2839                                                {
2840                                                  /* 33222222222211111111110000000000
2841                                                     10987654321098765432109876543210
2842                                                     xxxxxxxxxx01001xxxxxx0x101011xxx
2843                                                     crc32w.  */
2844                                                  return 718;
2845                                                }
2846                                            }
2847                                          else
2848                                            {
2849                                              if (((word >> 30) & 0x1) == 0)
2850                                                {
2851                                                  /* 33222222222211111111110000000000
2852                                                     10987654321098765432109876543210
2853                                                     xxxxxxxxxx0101xxxxxxx0x101011x0x
2854                                                     asrv.  */
2855                                                  return 711;
2856                                                }
2857                                              else
2858                                                {
2859                                                  /* 33222222222211111111110000000000
2860                                                     10987654321098765432109876543210
2861                                                     xxxxxxxxxx0101xxxxxxx0x101011x1x
2862                                                     pacdza.  */
2863                                                  return 697;
2864                                                }
2865                                            }
2866                                        }
2867                                      else
2868                                        {
2869                                          if (((word >> 13) & 0x1) == 0)
2870                                            {
2871                                              if (((word >> 14) & 0x1) == 0)
2872                                                {
2873                                                  /* 33222222222211111111110000000000
2874                                                     10987654321098765432109876543210
2875                                                     xxxxxxxxxx01100xxxxxx0x101011xxx
2876                                                     autda.  */
2877                                                  return 693;
2878                                                }
2879                                              else
2880                                                {
2881                                                  /* 33222222222211111111110000000000
2882                                                     10987654321098765432109876543210
2883                                                     xxxxxxxxxx01101xxxxxx0x101011xxx
2884                                                     crc32cw.  */
2885                                                  return 722;
2886                                                }
2887                                            }
2888                                          else
2889                                            {
2890                                              /* 33222222222211111111110000000000
2891                                                 10987654321098765432109876543210
2892                                                 xxxxxxxxxx0111xxxxxxx0x101011xxx
2893                                                 autdza.  */
2894                                              return 701;
2895                                            }
2896                                        }
2897                                    }
2898                                }
2899                            }
2900                          else
2901                            {
2902                              if (((word >> 11) & 0x1) == 0)
2903                                {
2904                                  if (((word >> 22) & 0x1) == 0)
2905                                    {
2906                                      if (((word >> 30) & 0x1) == 0)
2907                                        {
2908                                          /* 33222222222211111111110000000000
2909                                             10987654321098765432109876543210
2910                                             xxxxxxxxxx10xxxxxxxxx00x01011x0x
2911                                             csinc.  */
2912                                          return 657;
2913                                        }
2914                                      else
2915                                        {
2916                                          /* 33222222222211111111110000000000
2917                                             10987654321098765432109876543210
2918                                             xxxxxxxxxx10xxxxxxxxx00x01011x1x
2919                                             csneg.  */
2920                                          return 663;
2921                                        }
2922                                    }
2923                                  else
2924                                    {
2925                                      if (((word >> 12) & 0x1) == 0)
2926                                        {
2927                                          if (((word >> 13) & 0x1) == 0)
2928                                            {
2929                                              if (((word >> 14) & 0x1) == 0)
2930                                                {
2931                                                  if (((word >> 16) & 0x1) == 0)
2932                                                    {
2933                                                      /* 33222222222211111111110000000000
2934                                                         10987654321098765432109876543210
2935                                                         xxxxxxxxxx10000x0xxxx01x01011xxx
2936                                                         rev16.  */
2937                                                      return 680;
2938                                                    }
2939                                                  else
2940                                                    {
2941                                                      /* 33222222222211111111110000000000
2942                                                         10987654321098765432109876543210
2943                                                         xxxxxxxxxx10000x1xxxx01x01011xxx
2944                                                         pacib.  */
2945                                                      return 688;
2946                                                    }
2947                                                }
2948                                              else
2949                                                {
2950                                                  if (((word >> 30) & 0x1) == 0)
2951                                                    {
2952                                                      /* 33222222222211111111110000000000
2953                                                         10987654321098765432109876543210
2954                                                         xxxxxxxxxx10001xxxxxx01x01011x0x
2955                                                         crc32h.  */
2956                                                      return 717;
2957                                                    }
2958                                                  else
2959                                                    {
2960                                                      /* 33222222222211111111110000000000
2961                                                         10987654321098765432109876543210
2962                                                         xxxxxxxxxx10001xxxxxx01x01011x1x
2963                                                         xpacd.  */
2964                                                      return 704;
2965                                                    }
2966                                                }
2967                                            }
2968                                          else
2969                                            {
2970                                              if (((word >> 30) & 0x1) == 0)
2971                                                {
2972                                                  /* 33222222222211111111110000000000
2973                                                     10987654321098765432109876543210
2974                                                     xxxxxxxxxx1001xxxxxxx01x01011x0x
2975                                                     lsrv.  */
2976                                                  return 709;
2977                                                }
2978                                              else
2979                                                {
2980                                                  /* 33222222222211111111110000000000
2981                                                     10987654321098765432109876543210
2982                                                     xxxxxxxxxx1001xxxxxxx01x01011x1x
2983                                                     pacizb.  */
2984                                                  return 696;
2985                                                }
2986                                            }
2987                                        }
2988                                      else
2989                                        {
2990                                          if (((word >> 13) & 0x1) == 0)
2991                                            {
2992                                              if (((word >> 14) & 0x1) == 0)
2993                                                {
2994                                                  if (((word >> 16) & 0x1) == 0)
2995                                                    {
2996                                                      /* 33222222222211111111110000000000
2997                                                         10987654321098765432109876543210
2998                                                         xxxxxxxxxx10100x0xxxx01x01011xxx
2999                                                         cls.  */
3000                                                      return 685;
3001                                                    }
3002                                                  else
3003                                                    {
3004                                                      /* 33222222222211111111110000000000
3005                                                         10987654321098765432109876543210
3006                                                         xxxxxxxxxx10100x1xxxx01x01011xxx
3007                                                         autib.  */
3008                                                      return 692;
3009                                                    }
3010                                                }
3011                                              else
3012                                                {
3013                                                  /* 33222222222211111111110000000000
3014                                                     10987654321098765432109876543210
3015                                                     xxxxxxxxxx10101xxxxxx01x01011xxx
3016                                                     crc32ch.  */
3017                                                  return 721;
3018                                                }
3019                                            }
3020                                          else
3021                                            {
3022                                              /* 33222222222211111111110000000000
3023                                                 10987654321098765432109876543210
3024                                                 xxxxxxxxxx1011xxxxxxx01x01011xxx
3025                                                 autizb.  */
3026                                              return 700;
3027                                            }
3028                                        }
3029                                    }
3030                                }
3031                              else
3032                                {
3033                                  if (((word >> 12) & 0x1) == 0)
3034                                    {
3035                                      if (((word >> 13) & 0x1) == 0)
3036                                        {
3037                                          if (((word >> 14) & 0x1) == 0)
3038                                            {
3039                                              if (((word >> 30) & 0x1) == 0)
3040                                                {
3041                                                  /* 33222222222211111111110000000000
3042                                                     10987654321098765432109876543210
3043                                                     xxxxxxxxxx11000xxxxxx0xx01011x0x
3044                                                     sdiv.  */
3045                                                  return 706;
3046                                                }
3047                                              else
3048                                                {
3049                                                  if (((word >> 16) & 0x1) == 0)
3050                                                    {
3051                                                      /* 33222222222211111111110000000000
3052                                                         10987654321098765432109876543210
3053                                                         xxxxxxxxxx11000x0xxxx0xx01011x1x
3054                                                         rev.  */
3055                                                      return 682;
3056                                                    }
3057                                                  else
3058                                                    {
3059                                                      /* 33222222222211111111110000000000
3060                                                         10987654321098765432109876543210
3061                                                         xxxxxxxxxx11000x1xxxx0xx01011x1x
3062                                                         pacdb.  */
3063                                                      return 690;
3064                                                    }
3065                                                }
3066                                            }
3067                                          else
3068                                            {
3069                                              /* 33222222222211111111110000000000
3070                                                 10987654321098765432109876543210
3071                                                 xxxxxxxxxx11001xxxxxx0xx01011xxx
3072                                                 crc32x.  */
3073                                              return 719;
3074                                            }
3075                                        }
3076                                      else
3077                                        {
3078                                          if (((word >> 30) & 0x1) == 0)
3079                                            {
3080                                              /* 33222222222211111111110000000000
3081                                                 10987654321098765432109876543210
3082                                                 xxxxxxxxxx1101xxxxxxx0xx01011x0x
3083                                                 rorv.  */
3084                                              return 713;
3085                                            }
3086                                          else
3087                                            {
3088                                              /* 33222222222211111111110000000000
3089                                                 10987654321098765432109876543210
3090                                                 xxxxxxxxxx1101xxxxxxx0xx01011x1x
3091                                                 pacdzb.  */
3092                                              return 698;
3093                                            }
3094                                        }
3095                                    }
3096                                  else
3097                                    {
3098                                      if (((word >> 13) & 0x1) == 0)
3099                                        {
3100                                          if (((word >> 14) & 0x1) == 0)
3101                                            {
3102                                              /* 33222222222211111111110000000000
3103                                                 10987654321098765432109876543210
3104                                                 xxxxxxxxxx11100xxxxxx0xx01011xxx
3105                                                 autdb.  */
3106                                              return 694;
3107                                            }
3108                                          else
3109                                            {
3110                                              /* 33222222222211111111110000000000
3111                                                 10987654321098765432109876543210
3112                                                 xxxxxxxxxx11101xxxxxx0xx01011xxx
3113                                                 crc32cx.  */
3114                                              return 723;
3115                                            }
3116                                        }
3117                                      else
3118                                        {
3119                                          /* 33222222222211111111110000000000
3120                                             10987654321098765432109876543210
3121                                             xxxxxxxxxx1111xxxxxxx0xx01011xxx
3122                                             autdzb.  */
3123                                          return 702;
3124                                        }
3125                                    }
3126                                }
3127                            }
3128                        }
3129                    }
3130                  else
3131                    {
3132                      if (((word >> 29) & 0x1) == 0)
3133                        {
3134                          if (((word >> 30) & 0x1) == 0)
3135                            {
3136                              /* 33222222222211111111110000000000
3137                                 10987654321098765432109876543210
3138                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
3139                                 bic.  */
3140                              return 967;
3141                            }
3142                          else
3143                            {
3144                              /* 33222222222211111111110000000000
3145                                 10987654321098765432109876543210
3146                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
3147                                 eon.  */
3148                              return 974;
3149                            }
3150                        }
3151                      else
3152                        {
3153                          if (((word >> 30) & 0x1) == 0)
3154                            {
3155                              /* 33222222222211111111110000000000
3156                                 10987654321098765432109876543210
3157                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
3158                                 orn.  */
3159                              return 971;
3160                            }
3161                          else
3162                            {
3163                              /* 33222222222211111111110000000000
3164                                 10987654321098765432109876543210
3165                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
3166                                 bics.  */
3167                              return 977;
3168                            }
3169                        }
3170                    }
3171                }
3172            }
3173          else
3174            {
3175              if (((word >> 27) & 0x1) == 0)
3176                {
3177                  if (((word >> 23) & 0x1) == 0)
3178                    {
3179                      if (((word >> 29) & 0x1) == 0)
3180                        {
3181                          if (((word >> 30) & 0x1) == 0)
3182                            {
3183                              /* 33222222222211111111110000000000
3184                                 10987654321098765432109876543210
3185                                 xxxxxxxxxxxxxxxxxxxxxxx01100x00x
3186                                 sbfm.  */
3187                              return 612;
3188                            }
3189                          else
3190                            {
3191                              /* 33222222222211111111110000000000
3192                                 10987654321098765432109876543210
3193                                 xxxxxxxxxxxxxxxxxxxxxxx01100x01x
3194                                 ubfm.  */
3195                              return 623;
3196                            }
3197                        }
3198                      else
3199                        {
3200                          /* 33222222222211111111110000000000
3201                             10987654321098765432109876543210
3202                             xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
3203                             bfm.  */
3204                          return 619;
3205                        }
3206                    }
3207                  else
3208                    {
3209                      /* 33222222222211111111110000000000
3210                         10987654321098765432109876543210
3211                         xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
3212                         extr.  */
3213                      return 746;
3214                    }
3215                }
3216              else
3217                {
3218                  if (((word >> 21) & 0x1) == 0)
3219                    {
3220                      if (((word >> 28) & 0x1) == 0)
3221                        {
3222                          if (((word >> 29) & 0x1) == 0)
3223                            {
3224                              if (((word >> 30) & 0x1) == 0)
3225                                {
3226                                  /* 33222222222211111111110000000000
3227                                     10987654321098765432109876543210
3228                                     xxxxxxxxxxxxxxxxxxxxx0xx1101000x
3229                                     add.  */
3230                                  return 19;
3231                                }
3232                              else
3233                                {
3234                                  /* 33222222222211111111110000000000
3235                                     10987654321098765432109876543210
3236                                     xxxxxxxxxxxxxxxxxxxxx0xx1101001x
3237                                     sub.  */
3238                                  return 22;
3239                                }
3240                            }
3241                          else
3242                            {
3243                              if (((word >> 30) & 0x1) == 0)
3244                                {
3245                                  /* 33222222222211111111110000000000
3246                                     10987654321098765432109876543210
3247                                     xxxxxxxxxxxxxxxxxxxxx0xx1101010x
3248                                     adds.  */
3249                                  return 20;
3250                                }
3251                              else
3252                                {
3253                                  /* 33222222222211111111110000000000
3254                                     10987654321098765432109876543210
3255                                     xxxxxxxxxxxxxxxxxxxxx0xx1101011x
3256                                     subs.  */
3257                                  return 24;
3258                                }
3259                            }
3260                        }
3261                      else
3262                        {
3263                          if (((word >> 15) & 0x1) == 0)
3264                            {
3265                              if (((word >> 22) & 0x1) == 0)
3266                                {
3267                                  /* 33222222222211111111110000000000
3268                                     10987654321098765432109876543210
3269                                     xxxxxxxxxxxxxxx0xxxxx00x11011xxx
3270                                     madd.  */
3271                                  return 724;
3272                                }
3273                              else
3274                                {
3275                                  if (((word >> 23) & 0x1) == 0)
3276                                    {
3277                                      /* 33222222222211111111110000000000
3278                                         10987654321098765432109876543210
3279                                         xxxxxxxxxxxxxxx0xxxxx01011011xxx
3280                                         smulh.  */
3281                                      return 732;
3282                                    }
3283                                  else
3284                                    {
3285                                      /* 33222222222211111111110000000000
3286                                         10987654321098765432109876543210
3287                                         xxxxxxxxxxxxxxx0xxxxx01111011xxx
3288                                         umulh.  */
3289                                      return 737;
3290                                    }
3291                                }
3292                            }
3293                          else
3294                            {
3295                              /* 33222222222211111111110000000000
3296                                 10987654321098765432109876543210
3297                                 xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
3298                                 msub.  */
3299                              return 726;
3300                            }
3301                        }
3302                    }
3303                  else
3304                    {
3305                      if (((word >> 23) & 0x1) == 0)
3306                        {
3307                          if (((word >> 28) & 0x1) == 0)
3308                            {
3309                              if (((word >> 29) & 0x1) == 0)
3310                                {
3311                                  if (((word >> 30) & 0x1) == 0)
3312                                    {
3313                                      /* 33222222222211111111110000000000
3314                                         10987654321098765432109876543210
3315                                         xxxxxxxxxxxxxxxxxxxxx1x01101000x
3316                                         add.  */
3317                                      return 6;
3318                                    }
3319                                  else
3320                                    {
3321                                      /* 33222222222211111111110000000000
3322                                         10987654321098765432109876543210
3323                                         xxxxxxxxxxxxxxxxxxxxx1x01101001x
3324                                         sub.  */
3325                                      return 9;
3326                                    }
3327                                }
3328                              else
3329                                {
3330                                  if (((word >> 30) & 0x1) == 0)
3331                                    {
3332                                      /* 33222222222211111111110000000000
3333                                         10987654321098765432109876543210
3334                                         xxxxxxxxxxxxxxxxxxxxx1x01101010x
3335                                         adds.  */
3336                                      return 7;
3337                                    }
3338                                  else
3339                                    {
3340                                      /* 33222222222211111111110000000000
3341                                         10987654321098765432109876543210
3342                                         xxxxxxxxxxxxxxxxxxxxx1x01101011x
3343                                         subs.  */
3344                                      return 10;
3345                                    }
3346                                }
3347                            }
3348                          else
3349                            {
3350                              if (((word >> 15) & 0x1) == 0)
3351                                {
3352                                  /* 33222222222211111111110000000000
3353                                     10987654321098765432109876543210
3354                                     xxxxxxxxxxxxxxx0xxxxx1x011011xxx
3355                                     smaddl.  */
3356                                  return 728;
3357                                }
3358                              else
3359                                {
3360                                  /* 33222222222211111111110000000000
3361                                     10987654321098765432109876543210
3362                                     xxxxxxxxxxxxxxx1xxxxx1x011011xxx
3363                                     smsubl.  */
3364                                  return 730;
3365                                }
3366                            }
3367                        }
3368                      else
3369                        {
3370                          if (((word >> 15) & 0x1) == 0)
3371                            {
3372                              /* 33222222222211111111110000000000
3373                                 10987654321098765432109876543210
3374                                 xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
3375                                 umaddl.  */
3376                              return 733;
3377                            }
3378                          else
3379                            {
3380                              /* 33222222222211111111110000000000
3381                                 10987654321098765432109876543210
3382                                 xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
3383                                 umsubl.  */
3384                              return 735;
3385                            }
3386                        }
3387                    }
3388                }
3389            }
3390        }
3391    }
3392  else
3393    {
3394      if (((word >> 27) & 0x1) == 0)
3395        {
3396          if (((word >> 28) & 0x1) == 0)
3397            {
3398              if (((word >> 24) & 0x1) == 0)
3399                {
3400                  if (((word >> 29) & 0x1) == 0)
3401                    {
3402                      if (((word >> 13) & 0x1) == 0)
3403                        {
3404                          if (((word >> 14) & 0x1) == 0)
3405                            {
3406                              if (((word >> 15) & 0x1) == 0)
3407                                {
3408                                  if (((word >> 21) & 0x1) == 0)
3409                                    {
3410                                      if (((word >> 30) & 0x1) == 0)
3411                                        {
3412                                          if (((word >> 31) & 0x1) == 0)
3413                                            {
3414                                              if (((word >> 16) & 0x1) == 0)
3415                                                {
3416                                                  if (((word >> 17) & 0x1) == 0)
3417                                                    {
3418                                                      if (((word >> 18) & 0x1) == 0)
3419                                                        {
3420                                                          if (((word >> 19) & 0x1) == 0)
3421                                                            {
3422                                                              if (((word >> 20) & 0x1) == 0)
3423                                                                {
3424                                                                  /* 33222222222211111111110000000000
3425                                                                     10987654321098765432109876543210
3426                                                                     xxxxxxxxxxxxx000000000xx0x100000
3427                                                                     add.  */
3428                                                                  return 1232;
3429                                                                }
3430                                                              else
3431                                                                {
3432                                                                  /* 33222222222211111111110000000000
3433                                                                     10987654321098765432109876543210
3434                                                                     xxxxxxxxxxxxx000000010xx0x100000
3435                                                                     mul.  */
3436                                                                  return 1685;
3437                                                                }
3438                                                            }
3439                                                          else
3440                                                            {
3441                                                              if (((word >> 20) & 0x1) == 0)
3442                                                                {
3443                                                                  /* 33222222222211111111110000000000
3444                                                                     10987654321098765432109876543210
3445                                                                     xxxxxxxxxxxxx000000100xx0x100000
3446                                                                     smax.  */
3447                                                                  return 1764;
3448                                                                }
3449                                                              else
3450                                                                {
3451                                                                  /* 33222222222211111111110000000000
3452                                                                     10987654321098765432109876543210
3453                                                                     xxxxxxxxxxxxx000000110xx0x100000
3454                                                                     orr.  */
3455                                                                  return 1696;
3456                                                                }
3457                                                            }
3458                                                        }
3459                                                      else
3460                                                        {
3461                                                          if (((word >> 19) & 0x1) == 0)
3462                                                            {
3463                                                              /* 33222222222211111111110000000000
3464                                                                 10987654321098765432109876543210
3465                                                                 xxxxxxxxxxxxx0000010x0xx0x100000
3466                                                                 sdiv.  */
3467                                                              return 1755;
3468                                                            }
3469                                                          else
3470                                                            {
3471                                                              /* 33222222222211111111110000000000
3472                                                                 10987654321098765432109876543210
3473                                                                 xxxxxxxxxxxxx0000011x0xx0x100000
3474                                                                 sabd.  */
3475                                                              return 1746;
3476                                                            }
3477                                                        }
3478                                                    }
3479                                                  else
3480                                                    {
3481                                                      if (((word >> 18) & 0x1) == 0)
3482                                                        {
3483                                                          if (((word >> 19) & 0x1) == 0)
3484                                                            {
3485                                                              /* 33222222222211111111110000000000
3486                                                                 10987654321098765432109876543210
3487                                                                 xxxxxxxxxxxxx0000100x0xx0x100000
3488                                                                 smulh.  */
3489                                                              return 1769;
3490                                                            }
3491                                                          else
3492                                                            {
3493                                                              if (((word >> 20) & 0x1) == 0)
3494                                                                {
3495                                                                  /* 33222222222211111111110000000000
3496                                                                     10987654321098765432109876543210
3497                                                                     xxxxxxxxxxxxx000010100xx0x100000
3498                                                                     smin.  */
3499                                                                  return 1767;
3500                                                                }
3501                                                              else
3502                                                                {
3503                                                                  /* 33222222222211111111110000000000
3504                                                                     10987654321098765432109876543210
3505                                                                     xxxxxxxxxxxxx000010110xx0x100000
3506                                                                     and.  */
3507                                                                  return 1240;
3508                                                                }
3509                                                            }
3510                                                        }
3511                                                      else
3512                                                        {
3513                                                          /* 33222222222211111111110000000000
3514                                                             10987654321098765432109876543210
3515                                                             xxxxxxxxxxxxx000011xx0xx0x100000
3516                                                             sdivr.  */
3517                                                          return 1756;
3518                                                        }
3519                                                    }
3520                                                }
3521                                              else
3522                                                {
3523                                                  if (((word >> 17) & 0x1) == 0)
3524                                                    {
3525                                                      if (((word >> 18) & 0x1) == 0)
3526                                                        {
3527                                                          if (((word >> 19) & 0x1) == 0)
3528                                                            {
3529                                                              /* 33222222222211111111110000000000
3530                                                                 10987654321098765432109876543210
3531                                                                 xxxxxxxxxxxxx0001000x0xx0x100000
3532                                                                 sub.  */
3533                                                              return 1885;
3534                                                            }
3535                                                          else
3536                                                            {
3537                                                              if (((word >> 20) & 0x1) == 0)
3538                                                                {
3539                                                                  /* 33222222222211111111110000000000
3540                                                                     10987654321098765432109876543210
3541                                                                     xxxxxxxxxxxxx000100100xx0x100000
3542                                                                     umax.  */
3543                                                                  return 1913;
3544                                                                }
3545                                                              else
3546                                                                {
3547                                                                  /* 33222222222211111111110000000000
3548                                                                     10987654321098765432109876543210
3549                                                                     xxxxxxxxxxxxx000100110xx0x100000
3550                                                                     eor.  */
3551                                                                  return 1327;
3552                                                                }
3553                                                            }
3554                                                        }
3555                                                      else
3556                                                        {
3557                                                          if (((word >> 19) & 0x1) == 0)
3558                                                            {
3559                                                              /* 33222222222211111111110000000000
3560                                                                 10987654321098765432109876543210
3561                                                                 xxxxxxxxxxxxx0001010x0xx0x100000
3562                                                                 udiv.  */
3563                                                              return 1907;
3564                                                            }
3565                                                          else
3566                                                            {
3567                                                              /* 33222222222211111111110000000000
3568                                                                 10987654321098765432109876543210
3569                                                                 xxxxxxxxxxxxx0001011x0xx0x100000
3570                                                                 uabd.  */
3571                                                              return 1898;
3572                                                            }
3573                                                        }
3574                                                    }
3575                                                  else
3576                                                    {
3577                                                      if (((word >> 18) & 0x1) == 0)
3578                                                        {
3579                                                          if (((word >> 19) & 0x1) == 0)
3580                                                            {
3581                                                              if (((word >> 20) & 0x1) == 0)
3582                                                                {
3583                                                                  /* 33222222222211111111110000000000
3584                                                                     10987654321098765432109876543210
3585                                                                     xxxxxxxxxxxxx000110000xx0x100000
3586                                                                     subr.  */
3587                                                                  return 1887;
3588                                                                }
3589                                                              else
3590                                                                {
3591                                                                  /* 33222222222211111111110000000000
3592                                                                     10987654321098765432109876543210
3593                                                                     xxxxxxxxxxxxx000110010xx0x100000
3594                                                                     umulh.  */
3595                                                                  return 1918;
3596                                                                }
3597                                                            }
3598                                                          else
3599                                                            {
3600                                                              if (((word >> 20) & 0x1) == 0)
3601                                                                {
3602                                                                  /* 33222222222211111111110000000000
3603                                                                     10987654321098765432109876543210
3604                                                                     xxxxxxxxxxxxx000110100xx0x100000
3605                                                                     umin.  */
3606                                                                  return 1916;
3607                                                                }
3608                                                              else
3609                                                                {
3610                                                                  /* 33222222222211111111110000000000
3611                                                                     10987654321098765432109876543210
3612                                                                     xxxxxxxxxxxxx000110110xx0x100000
3613                                                                     bic.  */
3614                                                                  return 1252;
3615                                                                }
3616                                                            }
3617                                                        }
3618                                                      else
3619                                                        {
3620                                                          /* 33222222222211111111110000000000
3621                                                             10987654321098765432109876543210
3622                                                             xxxxxxxxxxxxx000111xx0xx0x100000
3623                                                             udivr.  */
3624                                                          return 1908;
3625                                                        }
3626                                                    }
3627                                                }
3628                                            }
3629                                          else
3630                                            {
3631                                              if (((word >> 23) & 0x1) == 0)
3632                                                {
3633                                                  /* 33222222222211111111110000000000
3634                                                     10987654321098765432109876543210
3635                                                     xxxxxxxxxxxxx000xxxxx0x00x100001
3636                                                     ld1sb.  */
3637                                                  return 1514;
3638                                                }
3639                                              else
3640                                                {
3641                                                  /* 33222222222211111111110000000000
3642                                                     10987654321098765432109876543210
3643                                                     xxxxxxxxxxxxx000xxxxx0x10x100001
3644                                                     ld1sh.  */
3645                                                  return 1525;
3646                                                }
3647                                            }
3648                                        }
3649                                      else
3650                                        {
3651                                          if (((word >> 23) & 0x1) == 0)
3652                                            {
3653                                              /* 33222222222211111111110000000000
3654                                                 10987654321098765432109876543210
3655                                                 xxxxxxxxxxxxx000xxxxx0x00x10001x
3656                                                 ld1sb.  */
3657                                              return 1518;
3658                                            }
3659                                          else
3660                                            {
3661                                              if (((word >> 31) & 0x1) == 0)
3662                                                {
3663                                                  if (((word >> 10) & 0x1) == 0)
3664                                                    {
3665                                                      /* 33222222222211111111110000000000
3666                                                         10987654321098765432109876543210
3667                                                         xxxxxxxxxx0xx000xxxxx0x10x100010
3668                                                         sdot.  */
3669                                                      return 1757;
3670                                                    }
3671                                                  else
3672                                                    {
3673                                                      /* 33222222222211111111110000000000
3674                                                         10987654321098765432109876543210
3675                                                         xxxxxxxxxx1xx000xxxxx0x10x100010
3676                                                         udot.  */
3677                                                      return 1909;
3678                                                    }
3679                                                }
3680                                              else
3681                                                {
3682                                                  /* 33222222222211111111110000000000
3683                                                     10987654321098765432109876543210
3684                                                     xxxxxxxxxxxxx000xxxxx0x10x100011
3685                                                     ld1sh.  */
3686                                                  return 1529;
3687                                                }
3688                                            }
3689                                        }
3690                                    }
3691                                  else
3692                                    {
3693                                      if (((word >> 30) & 0x1) == 0)
3694                                        {
3695                                          if (((word >> 31) & 0x1) == 0)
3696                                            {
3697                                              if (((word >> 10) & 0x1) == 0)
3698                                                {
3699                                                  if (((word >> 11) & 0x1) == 0)
3700                                                    {
3701                                                      if (((word >> 12) & 0x1) == 0)
3702                                                        {
3703                                                          /* 33222222222211111111110000000000
3704                                                             10987654321098765432109876543210
3705                                                             xxxxxxxxxx000000xxxxx1xx0x100000
3706                                                             add.  */
3707                                                          return 1230;
3708                                                        }
3709                                                      else
3710                                                        {
3711                                                          /* 33222222222211111111110000000000
3712                                                             10987654321098765432109876543210
3713                                                             xxxxxxxxxx001000xxxxx1xx0x100000
3714                                                             sqadd.  */
3715                                                          return 1771;
3716                                                        }
3717                                                    }
3718                                                  else
3719                                                    {
3720                                                      /* 33222222222211111111110000000000
3721                                                         10987654321098765432109876543210
3722                                                         xxxxxxxxxx01x000xxxxx1xx0x100000
3723                                                         sqsub.  */
3724                                                      return 1801;
3725                                                    }
3726                                                }
3727                                              else
3728                                                {
3729                                                  if (((word >> 11) & 0x1) == 0)
3730                                                    {
3731                                                      if (((word >> 12) & 0x1) == 0)
3732                                                        {
3733                                                          /* 33222222222211111111110000000000
3734                                                             10987654321098765432109876543210
3735                                                             xxxxxxxxxx100000xxxxx1xx0x100000
3736                                                             sub.  */
3737                                                          return 1883;
3738                                                        }
3739                                                      else
3740                                                        {
3741                                                          /* 33222222222211111111110000000000
3742                                                             10987654321098765432109876543210
3743                                                             xxxxxxxxxx101000xxxxx1xx0x100000
3744                                                             uqadd.  */
3745                                                          return 1919;
3746                                                        }
3747                                                    }
3748                                                  else
3749                                                    {
3750                                                      /* 33222222222211111111110000000000
3751                                                         10987654321098765432109876543210
3752                                                         xxxxxxxxxx11x000xxxxx1xx0x100000
3753                                                         uqsub.  */
3754                                                      return 1949;
3755                                                    }
3756                                                }
3757                                            }
3758                                          else
3759                                            {
3760                                              if (((word >> 23) & 0x1) == 0)
3761                                                {
3762                                                  /* 33222222222211111111110000000000
3763                                                     10987654321098765432109876543210
3764                                                     xxxxxxxxxxxxx000xxxxx1x00x100001
3765                                                     prfb.  */
3766                                                  return 1704;
3767                                                }
3768                                              else
3769                                                {
3770                                                  /* 33222222222211111111110000000000
3771                                                     10987654321098765432109876543210
3772                                                     xxxxxxxxxxxxx000xxxxx1x10x100001
3773                                                     ld1sh.  */
3774                                                  return 1526;
3775                                                }
3776                                            }
3777                                        }
3778                                      else
3779                                        {
3780                                          if (((word >> 23) & 0x1) == 0)
3781                                            {
3782                                              /* 33222222222211111111110000000000
3783                                                 10987654321098765432109876543210
3784                                                 xxxxxxxxxxxxx000xxxxx1x00x10001x
3785                                                 prfb.  */
3786                                              return 1705;
3787                                            }
3788                                          else
3789                                            {
3790                                              if (((word >> 31) & 0x1) == 0)
3791                                                {
3792                                                  if (((word >> 10) & 0x1) == 0)
3793                                                    {
3794                                                      if (((word >> 22) & 0x1) == 0)
3795                                                        {
3796                                                          /* 33222222222211111111110000000000
3797                                                             10987654321098765432109876543210
3798                                                             xxxxxxxxxx0xx000xxxxx1010x100010
3799                                                             sdot.  */
3800                                                          return 1758;
3801                                                        }
3802                                                      else
3803                                                        {
3804                                                          /* 33222222222211111111110000000000
3805                                                             10987654321098765432109876543210
3806                                                             xxxxxxxxxx0xx000xxxxx1110x100010
3807                                                             sdot.  */
3808                                                          return 1759;
3809                                                        }
3810                                                    }
3811                                                  else
3812                                                    {
3813                                                      if (((word >> 22) & 0x1) == 0)
3814                                                        {
3815                                                          /* 33222222222211111111110000000000
3816                                                             10987654321098765432109876543210
3817                                                             xxxxxxxxxx1xx000xxxxx1010x100010
3818                                                             udot.  */
3819                                                          return 1910;
3820                                                        }
3821                                                      else
3822                                                        {
3823                                                          /* 33222222222211111111110000000000
3824                                                             10987654321098765432109876543210
3825                                                             xxxxxxxxxx1xx000xxxxx1110x100010
3826                                                             udot.  */
3827                                                          return 1911;
3828                                                        }
3829                                                    }
3830                                                }
3831                                              else
3832                                                {
3833                                                  /* 33222222222211111111110000000000
3834                                                     10987654321098765432109876543210
3835                                                     xxxxxxxxxxxxx000xxxxx1x10x100011
3836                                                     ld1sh.  */
3837                                                  return 1530;
3838                                                }
3839                                            }
3840                                        }
3841                                    }
3842                                }
3843                              else
3844                                {
3845                                  if (((word >> 30) & 0x1) == 0)
3846                                    {
3847                                      if (((word >> 31) & 0x1) == 0)
3848                                        {
3849                                          if (((word >> 21) & 0x1) == 0)
3850                                            {
3851                                              if (((word >> 16) & 0x1) == 0)
3852                                                {
3853                                                  if (((word >> 18) & 0x1) == 0)
3854                                                    {
3855                                                      if (((word >> 19) & 0x1) == 0)
3856                                                        {
3857                                                          if (((word >> 20) & 0x1) == 0)
3858                                                            {
3859                                                              /* 33222222222211111111110000000000
3860                                                                 10987654321098765432109876543210
3861                                                                 xxxxxxxxxxxxx0010x0000xx0x100000
3862                                                                 asr.  */
3863                                                              return 1248;
3864                                                            }
3865                                                          else
3866                                                            {
3867                                                              /* 33222222222211111111110000000000
3868                                                                 10987654321098765432109876543210
3869                                                                 xxxxxxxxxxxxx0010x0010xx0x100000
3870                                                                 asr.  */
3871                                                              return 1246;
3872                                                            }
3873                                                        }
3874                                                      else
3875                                                        {
3876                                                          /* 33222222222211111111110000000000
3877                                                             10987654321098765432109876543210
3878                                                             xxxxxxxxxxxxx0010x01x0xx0x100000
3879                                                             asr.  */
3880                                                          return 1247;
3881                                                        }
3882                                                    }
3883                                                  else
3884                                                    {
3885                                                      if (((word >> 20) & 0x1) == 0)
3886                                                        {
3887                                                          /* 33222222222211111111110000000000
3888                                                             10987654321098765432109876543210
3889                                                             xxxxxxxxxxxxx0010x1x00xx0x100000
3890                                                             asrd.  */
3891                                                          return 1249;
3892                                                        }
3893                                                      else
3894                                                        {
3895                                                          /* 33222222222211111111110000000000
3896                                                             10987654321098765432109876543210
3897                                                             xxxxxxxxxxxxx0010x1x10xx0x100000
3898                                                             asrr.  */
3899                                                          return 1250;
3900                                                        }
3901                                                    }
3902                                                }
3903                                              else
3904                                                {
3905                                                  if (((word >> 17) & 0x1) == 0)
3906                                                    {
3907                                                      if (((word >> 18) & 0x1) == 0)
3908                                                        {
3909                                                          if (((word >> 19) & 0x1) == 0)
3910                                                            {
3911                                                              if (((word >> 20) & 0x1) == 0)
3912                                                                {
3913                                                                  /* 33222222222211111111110000000000
3914                                                                     10987654321098765432109876543210
3915                                                                     xxxxxxxxxxxxx001100000xx0x100000
3916                                                                     lsr.  */
3917                                                                  return 1676;
3918                                                                }
3919                                                              else
3920                                                                {
3921                                                                  /* 33222222222211111111110000000000
3922                                                                     10987654321098765432109876543210
3923                                                                     xxxxxxxxxxxxx001100010xx0x100000
3924                                                                     lsr.  */
3925                                                                  return 1674;
3926                                                                }
3927                                                            }
3928                                                          else
3929                                                            {
3930                                                              /* 33222222222211111111110000000000
3931                                                                 10987654321098765432109876543210
3932                                                                 xxxxxxxxxxxxx0011001x0xx0x100000
3933                                                                 lsr.  */
3934                                                              return 1675;
3935                                                            }
3936                                                        }
3937                                                      else
3938                                                        {
3939                                                          /* 33222222222211111111110000000000
3940                                                             10987654321098765432109876543210
3941                                                             xxxxxxxxxxxxx001101xx0xx0x100000
3942                                                             lsrr.  */
3943                                                          return 1677;
3944                                                        }
3945                                                    }
3946                                                  else
3947                                                    {
3948                                                      if (((word >> 18) & 0x1) == 0)
3949                                                        {
3950                                                          if (((word >> 19) & 0x1) == 0)
3951                                                            {
3952                                                              if (((word >> 20) & 0x1) == 0)
3953                                                                {
3954                                                                  /* 33222222222211111111110000000000
3955                                                                     10987654321098765432109876543210
3956                                                                     xxxxxxxxxxxxx001110000xx0x100000
3957                                                                     lsl.  */
3958                                                                  return 1670;
3959                                                                }
3960                                                              else
3961                                                                {
3962                                                                  /* 33222222222211111111110000000000
3963                                                                     10987654321098765432109876543210
3964                                                                     xxxxxxxxxxxxx001110010xx0x100000
3965                                                                     lsl.  */
3966                                                                  return 1668;
3967                                                                }
3968                                                            }
3969                                                          else
3970                                                            {
3971                                                              /* 33222222222211111111110000000000
3972                                                                 10987654321098765432109876543210
3973                                                                 xxxxxxxxxxxxx0011101x0xx0x100000
3974                                                                 lsl.  */
3975                                                              return 1669;
3976                                                            }
3977                                                        }
3978                                                      else
3979                                                        {
3980                                                          /* 33222222222211111111110000000000
3981                                                             10987654321098765432109876543210
3982                                                             xxxxxxxxxxxxx001111xx0xx0x100000
3983                                                             lslr.  */
3984                                                          return 1671;
3985                                                        }
3986                                                    }
3987                                                }
3988                                            }
3989                                          else
3990                                            {
3991                                              if (((word >> 10) & 0x1) == 0)
3992                                                {
3993                                                  if (((word >> 12) & 0x1) == 0)
3994                                                    {
3995                                                      /* 33222222222211111111110000000000
3996                                                         10987654321098765432109876543210
3997                                                         xxxxxxxxxx0x0001xxxxx1xx0x100000
3998                                                         asr.  */
3999                                                      return 1244;
4000                                                    }
4001                                                  else
4002                                                    {
4003                                                      /* 33222222222211111111110000000000
4004                                                         10987654321098765432109876543210
4005                                                         xxxxxxxxxx0x1001xxxxx1xx0x100000
4006                                                         asr.  */
4007                                                      return 1245;
4008                                                    }
4009                                                }
4010                                              else
4011                                                {
4012                                                  if (((word >> 11) & 0x1) == 0)
4013                                                    {
4014                                                      if (((word >> 12) & 0x1) == 0)
4015                                                        {
4016                                                          /* 33222222222211111111110000000000
4017                                                             10987654321098765432109876543210
4018                                                             xxxxxxxxxx100001xxxxx1xx0x100000
4019                                                             lsr.  */
4020                                                          return 1672;
4021                                                        }
4022                                                      else
4023                                                        {
4024                                                          /* 33222222222211111111110000000000
4025                                                             10987654321098765432109876543210
4026                                                             xxxxxxxxxx101001xxxxx1xx0x100000
4027                                                             lsr.  */
4028                                                          return 1673;
4029                                                        }
4030                                                    }
4031                                                  else
4032                                                    {
4033                                                      if (((word >> 12) & 0x1) == 0)
4034                                                        {
4035                                                          /* 33222222222211111111110000000000
4036                                                             10987654321098765432109876543210
4037                                                             xxxxxxxxxx110001xxxxx1xx0x100000
4038                                                             lsl.  */
4039                                                          return 1666;
4040                                                        }
4041                                                      else
4042                                                        {
4043                                                          /* 33222222222211111111110000000000
4044                                                             10987654321098765432109876543210
4045                                                             xxxxxxxxxx111001xxxxx1xx0x100000
4046                                                             lsl.  */
4047                                                          return 1667;
4048                                                        }
4049                                                    }
4050                                                }
4051                                            }
4052                                        }
4053                                      else
4054                                        {
4055                                          if (((word >> 22) & 0x1) == 0)
4056                                            {
4057                                              if (((word >> 23) & 0x1) == 0)
4058                                                {
4059                                                  /* 33222222222211111111110000000000
4060                                                     10987654321098765432109876543210
4061                                                     xxxxxxxxxxxxx001xxxxxx000x100001
4062                                                     ld1sb.  */
4063                                                  return 1520;
4064                                                }
4065                                              else
4066                                                {
4067                                                  /* 33222222222211111111110000000000
4068                                                     10987654321098765432109876543210
4069                                                     xxxxxxxxxxxxx001xxxxxx010x100001
4070                                                     ld1sh.  */
4071                                                  return 1533;
4072                                                }
4073                                            }
4074                                          else
4075                                            {
4076                                              if (((word >> 23) & 0x1) == 0)
4077                                                {
4078                                                  /* 33222222222211111111110000000000
4079                                                     10987654321098765432109876543210
4080                                                     xxxxxxxxxxxxx001xxxxxx100x100001
4081                                                     ld1rb.  */
4082                                                  return 1490;
4083                                                }
4084                                              else
4085                                                {
4086                                                  /* 33222222222211111111110000000000
4087                                                     10987654321098765432109876543210
4088                                                     xxxxxxxxxxxxx001xxxxxx110x100001
4089                                                     ld1rsw.  */
4090                                                  return 1511;
4091                                                }
4092                                            }
4093                                        }
4094                                    }
4095                                  else
4096                                    {
4097                                      if (((word >> 21) & 0x1) == 0)
4098                                        {
4099                                          if (((word >> 23) & 0x1) == 0)
4100                                            {
4101                                              /* 33222222222211111111110000000000
4102                                                 10987654321098765432109876543210
4103                                                 xxxxxxxxxxxxx001xxxxx0x00x10001x
4104                                                 ld1sb.  */
4105                                              return 1519;
4106                                            }
4107                                          else
4108                                            {
4109                                              /* 33222222222211111111110000000000
4110                                                 10987654321098765432109876543210
4111                                                 xxxxxxxxxxxxx001xxxxx0x10x10001x
4112                                                 ld1sh.  */
4113                                              return 1531;
4114                                            }
4115                                        }
4116                                      else
4117                                        {
4118                                          if (((word >> 22) & 0x1) == 0)
4119                                            {
4120                                              if (((word >> 23) & 0x1) == 0)
4121                                                {
4122                                                  /* 33222222222211111111110000000000
4123                                                     10987654321098765432109876543210
4124                                                     xxxxxxxxxxxxx001xxxxx1000x10001x
4125                                                     ld1sb.  */
4126                                                  return 1524;
4127                                                }
4128                                              else
4129                                                {
4130                                                  /* 33222222222211111111110000000000
4131                                                     10987654321098765432109876543210
4132                                                     xxxxxxxxxxxxx001xxxxx1010x10001x
4133                                                     ld1sh.  */
4134                                                  return 1536;
4135                                                }
4136                                            }
4137                                          else
4138                                            {
4139                                              if (((word >> 23) & 0x1) == 0)
4140                                                {
4141                                                  /* 33222222222211111111110000000000
4142                                                     10987654321098765432109876543210
4143                                                     xxxxxxxxxxxxx001xxxxx1100x10001x
4144                                                     prfb.  */
4145                                                  return 1706;
4146                                                }
4147                                              else
4148                                                {
4149                                                  /* 33222222222211111111110000000000
4150                                                     10987654321098765432109876543210
4151                                                     xxxxxxxxxxxxx001xxxxx1110x10001x
4152                                                     ld1sh.  */
4153                                                  return 1532;
4154                                                }
4155                                            }
4156                                        }
4157                                    }
4158                                }
4159                            }
4160                          else
4161                            {
4162                              if (((word >> 15) & 0x1) == 0)
4163                                {
4164                                  if (((word >> 21) & 0x1) == 0)
4165                                    {
4166                                      if (((word >> 30) & 0x1) == 0)
4167                                        {
4168                                          if (((word >> 31) & 0x1) == 0)
4169                                            {
4170                                              /* 33222222222211111111110000000000
4171                                                 10987654321098765432109876543210
4172                                                 xxxxxxxxxxxxx010xxxxx0xx0x100000
4173                                                 mla.  */
4174                                              return 1679;
4175                                            }
4176                                          else
4177                                            {
4178                                              if (((word >> 23) & 0x1) == 0)
4179                                                {
4180                                                  /* 33222222222211111111110000000000
4181                                                     10987654321098765432109876543210
4182                                                     xxxxxxxxxxxxx010xxxxx0x00x100001
4183                                                     ld1b.  */
4184                                                  return 1456;
4185                                                }
4186                                              else
4187                                                {
4188                                                  /* 33222222222211111111110000000000
4189                                                     10987654321098765432109876543210
4190                                                     xxxxxxxxxxxxx010xxxxx0x10x100001
4191                                                     ld1h.  */
4192                                                  return 1476;
4193                                                }
4194                                            }
4195                                        }
4196                                      else
4197                                        {
4198                                          if (((word >> 23) & 0x1) == 0)
4199                                            {
4200                                              /* 33222222222211111111110000000000
4201                                                 10987654321098765432109876543210
4202                                                 xxxxxxxxxxxxx010xxxxx0x00x10001x
4203                                                 ld1b.  */
4204                                              return 1461;
4205                                            }
4206                                          else
4207                                            {
4208                                              /* 33222222222211111111110000000000
4209                                                 10987654321098765432109876543210
4210                                                 xxxxxxxxxxxxx010xxxxx0x10x10001x
4211                                                 ld1h.  */
4212                                              return 1481;
4213                                            }
4214                                        }
4215                                    }
4216                                  else
4217                                    {
4218                                      if (((word >> 30) & 0x1) == 0)
4219                                        {
4220                                          if (((word >> 31) & 0x1) == 0)
4221                                            {
4222                                              if (((word >> 11) & 0x1) == 0)
4223                                                {
4224                                                  if (((word >> 12) & 0x1) == 0)
4225                                                    {
4226                                                      if (((word >> 10) & 0x1) == 0)
4227                                                        {
4228                                                          /* 33222222222211111111110000000000
4229                                                             10987654321098765432109876543210
4230                                                             xxxxxxxxxx000010xxxxx1xx0x100000
4231                                                             index.  */
4232                                                          return 1447;
4233                                                        }
4234                                                      else
4235                                                        {
4236                                                          /* 33222222222211111111110000000000
4237                                                             10987654321098765432109876543210
4238                                                             xxxxxxxxxx100010xxxxx1xx0x100000
4239                                                             index.  */
4240                                                          return 1448;
4241                                                        }
4242                                                    }
4243                                                  else
4244                                                    {
4245                                                      if (((word >> 22) & 0x1) == 0)
4246                                                        {
4247                                                          if (((word >> 23) & 0x1) == 0)
4248                                                            {
4249                                                              /* 33222222222211111111110000000000
4250                                                                 10987654321098765432109876543210
4251                                                                 xxxxxxxxxxx01010xxxxx1000x100000
4252                                                                 addvl.  */
4253                                                              return 1234;
4254                                                            }
4255                                                          else
4256                                                            {
4257                                                              /* 33222222222211111111110000000000
4258                                                                 10987654321098765432109876543210
4259                                                                 xxxxxxxxxxx01010xxxxx1010x100000
4260                                                                 rdvl.  */
4261                                                              return 1740;
4262                                                            }
4263                                                        }
4264                                                      else
4265                                                        {
4266                                                          /* 33222222222211111111110000000000
4267                                                             10987654321098765432109876543210
4268                                                             xxxxxxxxxxx01010xxxxx11x0x100000
4269                                                             addpl.  */
4270                                                          return 1233;
4271                                                        }
4272                                                    }
4273                                                }
4274                                              else
4275                                                {
4276                                                  if (((word >> 10) & 0x1) == 0)
4277                                                    {
4278                                                      /* 33222222222211111111110000000000
4279                                                         10987654321098765432109876543210
4280                                                         xxxxxxxxxx01x010xxxxx1xx0x100000
4281                                                         index.  */
4282                                                      return 1449;
4283                                                    }
4284                                                  else
4285                                                    {
4286                                                      /* 33222222222211111111110000000000
4287                                                         10987654321098765432109876543210
4288                                                         xxxxxxxxxx11x010xxxxx1xx0x100000
4289                                                         index.  */
4290                                                      return 1446;
4291                                                    }
4292                                                }
4293                                            }
4294                                          else
4295                                            {
4296                                              if (((word >> 23) & 0x1) == 0)
4297                                                {
4298                                                  /* 33222222222211111111110000000000
4299                                                     10987654321098765432109876543210
4300                                                     xxxxxxxxxxxxx010xxxxx1x00x100001
4301                                                     prfw.  */
4302                                                  return 1724;
4303                                                }
4304                                              else
4305                                                {
4306                                                  /* 33222222222211111111110000000000
4307                                                     10987654321098765432109876543210
4308                                                     xxxxxxxxxxxxx010xxxxx1x10x100001
4309                                                     ld1h.  */
4310                                                  return 1477;
4311                                                }
4312                                            }
4313                                        }
4314                                      else
4315                                        {
4316                                          if (((word >> 23) & 0x1) == 0)
4317                                            {
4318                                              /* 33222222222211111111110000000000
4319                                                 10987654321098765432109876543210
4320                                                 xxxxxxxxxxxxx010xxxxx1x00x10001x
4321                                                 prfw.  */
4322                                              return 1726;
4323                                            }
4324                                          else
4325                                            {
4326                                              /* 33222222222211111111110000000000
4327                                                 10987654321098765432109876543210
4328                                                 xxxxxxxxxxxxx010xxxxx1x10x10001x
4329                                                 ld1h.  */
4330                                              return 1482;
4331                                            }
4332                                        }
4333                                    }
4334                                }
4335                              else
4336                                {
4337                                  if (((word >> 30) & 0x1) == 0)
4338                                    {
4339                                      if (((word >> 31) & 0x1) == 0)
4340                                        {
4341                                          if (((word >> 21) & 0x1) == 0)
4342                                            {
4343                                              /* 33222222222211111111110000000000
4344                                                 10987654321098765432109876543210
4345                                                 xxxxxxxxxxxxx011xxxxx0xx0x100000
4346                                                 mad.  */
4347                                              return 1678;
4348                                            }
4349                                          else
4350                                            {
4351                                              if (((word >> 10) & 0x1) == 0)
4352                                                {
4353                                                  if (((word >> 11) & 0x1) == 0)
4354                                                    {
4355                                                      if (((word >> 20) & 0x1) == 0)
4356                                                        {
4357                                                          if (((word >> 22) & 0x1) == 0)
4358                                                            {
4359                                                              /* 33222222222211111111110000000000
4360                                                                 10987654321098765432109876543210
4361                                                                 xxxxxxxxxx00x011xxxx010x0x100000
4362                                                                 sqincw.  */
4363                                                              return 1798;
4364                                                            }
4365                                                          else
4366                                                            {
4367                                                              if (((word >> 23) & 0x1) == 0)
4368                                                                {
4369                                                                  /* 33222222222211111111110000000000
4370                                                                     10987654321098765432109876543210
4371                                                                     xxxxxxxxxx00x011xxxx01100x100000
4372                                                                     sqinch.  */
4373                                                                  return 1792;
4374                                                                }
4375                                                              else
4376                                                                {
4377                                                                  /* 33222222222211111111110000000000
4378                                                                     10987654321098765432109876543210
4379                                                                     xxxxxxxxxx00x011xxxx01110x100000
4380                                                                     sqincd.  */
4381                                                                  return 1789;
4382                                                                }
4383                                                            }
4384                                                        }
4385                                                      else
4386                                                        {
4387                                                          if (((word >> 22) & 0x1) == 0)
4388                                                            {
4389                                                              /* 33222222222211111111110000000000
4390                                                                 10987654321098765432109876543210
4391                                                                 xxxxxxxxxx00x011xxxx110x0x100000
4392                                                                 incw.  */
4393                                                              return 1444;
4394                                                            }
4395                                                          else
4396                                                            {
4397                                                              if (((word >> 23) & 0x1) == 0)
4398                                                                {
4399                                                                  /* 33222222222211111111110000000000
4400                                                                     10987654321098765432109876543210
4401                                                                     xxxxxxxxxx00x011xxxx11100x100000
4402                                                                     inch.  */
4403                                                                  return 1440;
4404                                                                }
4405                                                              else
4406                                                                {
4407                                                                  /* 33222222222211111111110000000000
4408                                                                     10987654321098765432109876543210
4409                                                                     xxxxxxxxxx00x011xxxx11110x100000
4410                                                                     incd.  */
4411                                                                  return 1438;
4412                                                                }
4413                                                            }
4414                                                        }
4415                                                    }
4416                                                  else
4417                                                    {
4418                                                      if (((word >> 22) & 0x1) == 0)
4419                                                        {
4420                                                          /* 33222222222211111111110000000000
4421                                                             10987654321098765432109876543210
4422                                                             xxxxxxxxxx01x011xxxxx10x0x100000
4423                                                             sqdecw.  */
4424                                                          return 1784;
4425                                                        }
4426                                                      else
4427                                                        {
4428                                                          if (((word >> 23) & 0x1) == 0)
4429                                                            {
4430                                                              /* 33222222222211111111110000000000
4431                                                                 10987654321098765432109876543210
4432                                                                 xxxxxxxxxx01x011xxxxx1100x100000
4433                                                                 sqdech.  */
4434                                                              return 1778;
4435                                                            }
4436                                                          else
4437                                                            {
4438                                                              /* 33222222222211111111110000000000
4439                                                                 10987654321098765432109876543210
4440                                                                 xxxxxxxxxx01x011xxxxx1110x100000
4441                                                                 sqdecd.  */
4442                                                              return 1775;
4443                                                            }
4444                                                        }
4445                                                    }
4446                                                }
4447                                              else
4448                                                {
4449                                                  if (((word >> 11) & 0x1) == 0)
4450                                                    {
4451                                                      if (((word >> 20) & 0x1) == 0)
4452                                                        {
4453                                                          if (((word >> 22) & 0x1) == 0)
4454                                                            {
4455                                                              /* 33222222222211111111110000000000
4456                                                                 10987654321098765432109876543210
4457                                                                 xxxxxxxxxx10x011xxxx010x0x100000
4458                                                                 uqincw.  */
4459                                                              return 1946;
4460                                                            }
4461                                                          else
4462                                                            {
4463                                                              if (((word >> 23) & 0x1) == 0)
4464                                                                {
4465                                                                  /* 33222222222211111111110000000000
4466                                                                     10987654321098765432109876543210
4467                                                                     xxxxxxxxxx10x011xxxx01100x100000
4468                                                                     uqinch.  */
4469                                                                  return 1940;
4470                                                                }
4471                                                              else
4472                                                                {
4473                                                                  /* 33222222222211111111110000000000
4474                                                                     10987654321098765432109876543210
4475                                                                     xxxxxxxxxx10x011xxxx01110x100000
4476                                                                     uqincd.  */
4477                                                                  return 1937;
4478                                                                }
4479                                                            }
4480                                                        }
4481                                                      else
4482                                                        {
4483                                                          if (((word >> 22) & 0x1) == 0)
4484                                                            {
4485                                                              /* 33222222222211111111110000000000
4486                                                                 10987654321098765432109876543210
4487                                                                 xxxxxxxxxx10x011xxxx110x0x100000
4488                                                                 decw.  */
4489                                                              return 1319;
4490                                                            }
4491                                                          else
4492                                                            {
4493                                                              if (((word >> 23) & 0x1) == 0)
4494                                                                {
4495                                                                  /* 33222222222211111111110000000000
4496                                                                     10987654321098765432109876543210
4497                                                                     xxxxxxxxxx10x011xxxx11100x100000
4498                                                                     dech.  */
4499                                                                  return 1315;
4500                                                                }
4501                                                              else
4502                                                                {
4503                                                                  /* 33222222222211111111110000000000
4504                                                                     10987654321098765432109876543210
4505                                                                     xxxxxxxxxx10x011xxxx11110x100000
4506                                                                     decd.  */
4507                                                                  return 1313;
4508                                                                }
4509                                                            }
4510                                                        }
4511                                                    }
4512                                                  else
4513                                                    {
4514                                                      if (((word >> 22) & 0x1) == 0)
4515                                                        {
4516                                                          /* 33222222222211111111110000000000
4517                                                             10987654321098765432109876543210
4518                                                             xxxxxxxxxx11x011xxxxx10x0x100000
4519                                                             uqdecw.  */
4520                                                          return 1932;
4521                                                        }
4522                                                      else
4523                                                        {
4524                                                          if (((word >> 23) & 0x1) == 0)
4525                                                            {
4526                                                              /* 33222222222211111111110000000000
4527                                                                 10987654321098765432109876543210
4528                                                                 xxxxxxxxxx11x011xxxxx1100x100000
4529                                                                 uqdech.  */
4530                                                              return 1926;
4531                                                            }
4532                                                          else
4533                                                            {
4534                                                              /* 33222222222211111111110000000000
4535                                                                 10987654321098765432109876543210
4536                                                                 xxxxxxxxxx11x011xxxxx1110x100000
4537                                                                 uqdecd.  */
4538                                                              return 1923;
4539                                                            }
4540                                                        }
4541                                                    }
4542                                                }
4543                                            }
4544                                        }
4545                                      else
4546                                        {
4547                                          if (((word >> 22) & 0x1) == 0)
4548                                            {
4549                                              if (((word >> 21) & 0x1) == 0)
4550                                                {
4551                                                  if (((word >> 23) & 0x1) == 0)
4552                                                    {
4553                                                      /* 33222222222211111111110000000000
4554                                                         10987654321098765432109876543210
4555                                                         xxxxxxxxxxxxx011xxxxx0000x100001
4556                                                         prfb.  */
4557                                                      return 1703;
4558                                                    }
4559                                                  else
4560                                                    {
4561                                                      /* 33222222222211111111110000000000
4562                                                         10987654321098765432109876543210
4563                                                         xxxxxxxxxxxxx011xxxxx0010x100001
4564                                                         prfh.  */
4565                                                      return 1718;
4566                                                    }
4567                                                }
4568                                              else
4569                                                {
4570                                                  if (((word >> 23) & 0x1) == 0)
4571                                                    {
4572                                                      /* 33222222222211111111110000000000
4573                                                         10987654321098765432109876543210
4574                                                         xxxxxxxxxxxxx011xxxxx1000x100001
4575                                                         ld1b.  */
4576                                                      return 1463;
4577                                                    }
4578                                                  else
4579                                                    {
4580                                                      /* 33222222222211111111110000000000
4581                                                         10987654321098765432109876543210
4582                                                         xxxxxxxxxxxxx011xxxxx1010x100001
4583                                                         ld1h.  */
4584                                                      return 1485;
4585                                                    }
4586                                                }
4587                                            }
4588                                          else
4589                                            {
4590                                              if (((word >> 23) & 0x1) == 0)
4591                                                {
4592                                                  /* 33222222222211111111110000000000
4593                                                     10987654321098765432109876543210
4594                                                     xxxxxxxxxxxxx011xxxxxx100x100001
4595                                                     ld1rb.  */
4596                                                  return 1492;
4597                                                }
4598                                              else
4599                                                {
4600                                                  /* 33222222222211111111110000000000
4601                                                     10987654321098765432109876543210
4602                                                     xxxxxxxxxxxxx011xxxxxx110x100001
4603                                                     ld1rh.  */
4604                                                  return 1496;
4605                                                }
4606                                            }
4607                                        }
4608                                    }
4609                                  else
4610                                    {
4611                                      if (((word >> 21) & 0x1) == 0)
4612                                        {
4613                                          if (((word >> 23) & 0x1) == 0)
4614                                            {
4615                                              /* 33222222222211111111110000000000
4616                                                 10987654321098765432109876543210
4617                                                 xxxxxxxxxxxxx011xxxxx0x00x10001x
4618                                                 ld1b.  */
4619                                              return 1462;
4620                                            }
4621                                          else
4622                                            {
4623                                              /* 33222222222211111111110000000000
4624                                                 10987654321098765432109876543210
4625                                                 xxxxxxxxxxxxx011xxxxx0x10x10001x
4626                                                 ld1h.  */
4627                                              return 1483;
4628                                            }
4629                                        }
4630                                      else
4631                                        {
4632                                          if (((word >> 22) & 0x1) == 0)
4633                                            {
4634                                              if (((word >> 23) & 0x1) == 0)
4635                                                {
4636                                                  /* 33222222222211111111110000000000
4637                                                     10987654321098765432109876543210
4638                                                     xxxxxxxxxxxxx011xxxxx1000x10001x
4639                                                     ld1b.  */
4640                                                  return 1468;
4641                                                }
4642                                              else
4643                                                {
4644                                                  /* 33222222222211111111110000000000
4645                                                     10987654321098765432109876543210
4646                                                     xxxxxxxxxxxxx011xxxxx1010x10001x
4647                                                     ld1h.  */
4648                                                  return 1489;
4649                                                }
4650                                            }
4651                                          else
4652                                            {
4653                                              if (((word >> 23) & 0x1) == 0)
4654                                                {
4655                                                  /* 33222222222211111111110000000000
4656                                                     10987654321098765432109876543210
4657                                                     xxxxxxxxxxxxx011xxxxx1100x10001x
4658                                                     prfw.  */
4659                                                  return 1727;
4660                                                }
4661                                              else
4662                                                {
4663                                                  /* 33222222222211111111110000000000
4664                                                     10987654321098765432109876543210
4665                                                     xxxxxxxxxxxxx011xxxxx1110x10001x
4666                                                     ld1h.  */
4667                                                  return 1484;
4668                                                }
4669                                            }
4670                                        }
4671                                    }
4672                                }
4673                            }
4674                        }
4675                      else
4676                        {
4677                          if (((word >> 14) & 0x1) == 0)
4678                            {
4679                              if (((word >> 15) & 0x1) == 0)
4680                                {
4681                                  if (((word >> 21) & 0x1) == 0)
4682                                    {
4683                                      if (((word >> 30) & 0x1) == 0)
4684                                        {
4685                                          if (((word >> 31) & 0x1) == 0)
4686                                            {
4687                                              if (((word >> 17) & 0x1) == 0)
4688                                                {
4689                                                  if (((word >> 19) & 0x1) == 0)
4690                                                    {
4691                                                      if (((word >> 20) & 0x1) == 0)
4692                                                        {
4693                                                          if (((word >> 16) & 0x1) == 0)
4694                                                            {
4695                                                              /* 33222222222211111111110000000000
4696                                                                 10987654321098765432109876543210
4697                                                                 xxxxxxxxxxxxx10000x000xx0x100000
4698                                                                 saddv.  */
4699                                                              return 1747;
4700                                                            }
4701                                                          else
4702                                                            {
4703                                                              /* 33222222222211111111110000000000
4704                                                                 10987654321098765432109876543210
4705                                                                 xxxxxxxxxxxxx10010x000xx0x100000
4706                                                                 uaddv.  */
4707                                                              return 1899;
4708                                                            }
4709                                                        }
4710                                                      else
4711                                                        {
4712                                                          /* 33222222222211111111110000000000
4713                                                             10987654321098765432109876543210
4714                                                             xxxxxxxxxxxxx100x0x010xx0x100000
4715                                                             movprfx.  */
4716                                                          return 1682;
4717                                                        }
4718                                                    }
4719                                                  else
4720                                                    {
4721                                                      if (((word >> 16) & 0x1) == 0)
4722                                                        {
4723                                                          if (((word >> 20) & 0x1) == 0)
4724                                                            {
4725                                                              /* 33222222222211111111110000000000
4726                                                                 10987654321098765432109876543210
4727                                                                 xxxxxxxxxxxxx10000x100xx0x100000
4728                                                                 smaxv.  */
4729                                                              return 1765;
4730                                                            }
4731                                                          else
4732                                                            {
4733                                                              /* 33222222222211111111110000000000
4734                                                                 10987654321098765432109876543210
4735                                                                 xxxxxxxxxxxxx10000x110xx0x100000
4736                                                                 orv.  */
4737                                                              return 1699;
4738                                                            }
4739                                                        }
4740                                                      else
4741                                                        {
4742                                                          if (((word >> 20) & 0x1) == 0)
4743                                                            {
4744                                                              /* 33222222222211111111110000000000
4745                                                                 10987654321098765432109876543210
4746                                                                 xxxxxxxxxxxxx10010x100xx0x100000
4747                                                                 umaxv.  */
4748                                                              return 1914;
4749                                                            }
4750                                                          else
4751                                                            {
4752                                                              /* 33222222222211111111110000000000
4753                                                                 10987654321098765432109876543210
4754                                                                 xxxxxxxxxxxxx10010x110xx0x100000
4755                                                                 eorv.  */
4756                                                              return 1330;
4757                                                            }
4758                                                        }
4759                                                    }
4760                                                }
4761                                              else
4762                                                {
4763                                                  if (((word >> 16) & 0x1) == 0)
4764                                                    {
4765                                                      if (((word >> 20) & 0x1) == 0)
4766                                                        {
4767                                                          /* 33222222222211111111110000000000
4768                                                             10987654321098765432109876543210
4769                                                             xxxxxxxxxxxxx10001xx00xx0x100000
4770                                                             sminv.  */
4771                                                          return 1768;
4772                                                        }
4773                                                      else
4774                                                        {
4775                                                          /* 33222222222211111111110000000000
4776                                                             10987654321098765432109876543210
4777                                                             xxxxxxxxxxxxx10001xx10xx0x100000
4778                                                             andv.  */
4779                                                          return 1243;
4780                                                        }
4781                                                    }
4782                                                  else
4783                                                    {
4784                                                      /* 33222222222211111111110000000000
4785                                                         10987654321098765432109876543210
4786                                                         xxxxxxxxxxxxx10011xxx0xx0x100000
4787                                                         uminv.  */
4788                                                      return 1917;
4789                                                    }
4790                                                }
4791                                            }
4792                                          else
4793                                            {
4794                                              if (((word >> 23) & 0x1) == 0)
4795                                                {
4796                                                  /* 33222222222211111111110000000000
4797                                                     10987654321098765432109876543210
4798                                                     xxxxxxxxxxxxx100xxxxx0x00x100001
4799                                                     ldff1sb.  */
4800                                                  return 1606;
4801                                                }
4802                                              else
4803                                                {
4804                                                  /* 33222222222211111111110000000000
4805                                                     10987654321098765432109876543210
4806                                                     xxxxxxxxxxxxx100xxxxx0x10x100001
4807                                                     ldff1sh.  */
4808                                                  return 1614;
4809                                                }
4810                                            }
4811                                        }
4812                                      else
4813                                        {
4814                                          if (((word >> 23) & 0x1) == 0)
4815                                            {
4816                                              /* 33222222222211111111110000000000
4817                                                 10987654321098765432109876543210
4818                                                 xxxxxxxxxxxxx100xxxxx0x00x10001x
4819                                                 ldff1sb.  */
4820                                              return 1610;
4821                                            }
4822                                          else
4823                                            {
4824                                              /* 33222222222211111111110000000000
4825                                                 10987654321098765432109876543210
4826                                                 xxxxxxxxxxxxx100xxxxx0x10x10001x
4827                                                 ldff1sh.  */
4828                                              return 1618;
4829                                            }
4830                                        }
4831                                    }
4832                                  else
4833                                    {
4834                                      if (((word >> 23) & 0x1) == 0)
4835                                        {
4836                                          if (((word >> 30) & 0x1) == 0)
4837                                            {
4838                                              if (((word >> 31) & 0x1) == 0)
4839                                                {
4840                                                  if (((word >> 22) & 0x1) == 0)
4841                                                    {
4842                                                      /* 33222222222211111111110000000000
4843                                                         10987654321098765432109876543210
4844                                                         xxxxxxxxxxxxx100xxxxx1000x100000
4845                                                         and.  */
4846                                                      return 1238;
4847                                                    }
4848                                                  else
4849                                                    {
4850                                                      /* 33222222222211111111110000000000
4851                                                         10987654321098765432109876543210
4852                                                         xxxxxxxxxxxxx100xxxxx1100x100000
4853                                                         orr.  */
4854                                                      return 1694;
4855                                                    }
4856                                                }
4857                                              else
4858                                                {
4859                                                  /* 33222222222211111111110000000000
4860                                                     10987654321098765432109876543210
4861                                                     xxxxxxxxxxxxx100xxxxx1x00x100001
4862                                                     prfh.  */
4863                                                  return 1717;
4864                                                }
4865                                            }
4866                                          else
4867                                            {
4868                                              /* 33222222222211111111110000000000
4869                                                 10987654321098765432109876543210
4870                                                 xxxxxxxxxxxxx100xxxxx1x00x10001x
4871                                                 prfh.  */
4872                                              return 1719;
4873                                            }
4874                                        }
4875                                      else
4876                                        {
4877                                          if (((word >> 30) & 0x1) == 0)
4878                                            {
4879                                              if (((word >> 31) & 0x1) == 0)
4880                                                {
4881                                                  if (((word >> 22) & 0x1) == 0)
4882                                                    {
4883                                                      /* 33222222222211111111110000000000
4884                                                         10987654321098765432109876543210
4885                                                         xxxxxxxxxxxxx100xxxxx1010x100000
4886                                                         eor.  */
4887                                                      return 1325;
4888                                                    }
4889                                                  else
4890                                                    {
4891                                                      /* 33222222222211111111110000000000
4892                                                         10987654321098765432109876543210
4893                                                         xxxxxxxxxxxxx100xxxxx1110x100000
4894                                                         bic.  */
4895                                                      return 1251;
4896                                                    }
4897                                                }
4898                                              else
4899                                                {
4900                                                  /* 33222222222211111111110000000000
4901                                                     10987654321098765432109876543210
4902                                                     xxxxxxxxxxxxx100xxxxx1x10x100001
4903                                                     ldff1sh.  */
4904                                                  return 1615;
4905                                                }
4906                                            }
4907                                          else
4908                                            {
4909                                              /* 33222222222211111111110000000000
4910                                                 10987654321098765432109876543210
4911                                                 xxxxxxxxxxxxx100xxxxx1x10x10001x
4912                                                 ldff1sh.  */
4913                                              return 1619;
4914                                            }
4915                                        }
4916                                    }
4917                                }
4918                              else
4919                                {
4920                                  if (((word >> 30) & 0x1) == 0)
4921                                    {
4922                                      if (((word >> 31) & 0x1) == 0)
4923                                        {
4924                                          if (((word >> 21) & 0x1) == 0)
4925                                            {
4926                                              if (((word >> 16) & 0x1) == 0)
4927                                                {
4928                                                  if (((word >> 17) & 0x1) == 0)
4929                                                    {
4930                                                      if (((word >> 18) & 0x1) == 0)
4931                                                        {
4932                                                          if (((word >> 19) & 0x1) == 0)
4933                                                            {
4934                                                              /* 33222222222211111111110000000000
4935                                                                 10987654321098765432109876543210
4936                                                                 xxxxxxxxxxxxx1010000x0xx0x100000
4937                                                                 sxtb.  */
4938                                                              return 1890;
4939                                                            }
4940                                                          else
4941                                                            {
4942                                                              /* 33222222222211111111110000000000
4943                                                                 10987654321098765432109876543210
4944                                                                 xxxxxxxxxxxxx1010001x0xx0x100000
4945                                                                 cls.  */
4946                                                              return 1271;
4947                                                            }
4948                                                        }
4949                                                      else
4950                                                        {
4951                                                          if (((word >> 19) & 0x1) == 0)
4952                                                            {
4953                                                              /* 33222222222211111111110000000000
4954                                                                 10987654321098765432109876543210
4955                                                                 xxxxxxxxxxxxx1010010x0xx0x100000
4956                                                                 sxtw.  */
4957                                                              return 1892;
4958                                                            }
4959                                                          else
4960                                                            {
4961                                                              /* 33222222222211111111110000000000
4962                                                                 10987654321098765432109876543210
4963                                                                 xxxxxxxxxxxxx1010011x0xx0x100000
4964                                                                 fabs.  */
4965                                                              return 1333;
4966                                                            }
4967                                                        }
4968                                                    }
4969                                                  else
4970                                                    {
4971                                                      if (((word >> 18) & 0x1) == 0)
4972                                                        {
4973                                                          if (((word >> 19) & 0x1) == 0)
4974                                                            {
4975                                                              /* 33222222222211111111110000000000
4976                                                                 10987654321098765432109876543210
4977                                                                 xxxxxxxxxxxxx1010100x0xx0x100000
4978                                                                 sxth.  */
4979                                                              return 1891;
4980                                                            }
4981                                                          else
4982                                                            {
4983                                                              /* 33222222222211111111110000000000
4984                                                                 10987654321098765432109876543210
4985                                                                 xxxxxxxxxxxxx1010101x0xx0x100000
4986                                                                 cnt.  */
4987                                                              return 1300;
4988                                                            }
4989                                                        }
4990                                                      else
4991                                                        {
4992                                                          if (((word >> 19) & 0x1) == 0)
4993                                                            {
4994                                                              /* 33222222222211111111110000000000
4995                                                                 10987654321098765432109876543210
4996                                                                 xxxxxxxxxxxxx1010110x0xx0x100000
4997                                                                 abs.  */
4998                                                              return 1229;
4999                                                            }
5000                                                          else
5001                                                            {
5002                                                              /* 33222222222211111111110000000000
5003                                                                 10987654321098765432109876543210
5004                                                                 xxxxxxxxxxxxx1010111x0xx0x100000
5005                                                                 not.  */
5006                                                              return 1691;
5007                                                            }
5008                                                        }
5009                                                    }
5010                                                }
5011                                              else
5012                                                {
5013                                                  if (((word >> 17) & 0x1) == 0)
5014                                                    {
5015                                                      if (((word >> 18) & 0x1) == 0)
5016                                                        {
5017                                                          if (((word >> 19) & 0x1) == 0)
5018                                                            {
5019                                                              /* 33222222222211111111110000000000
5020                                                                 10987654321098765432109876543210
5021                                                                 xxxxxxxxxxxxx1011000x0xx0x100000
5022                                                                 uxtb.  */
5023                                                              return 1953;
5024                                                            }
5025                                                          else
5026                                                            {
5027                                                              /* 33222222222211111111110000000000
5028                                                                 10987654321098765432109876543210
5029                                                                 xxxxxxxxxxxxx1011001x0xx0x100000
5030                                                                 clz.  */
5031                                                              return 1272;
5032                                                            }
5033                                                        }
5034                                                      else
5035                                                        {
5036                                                          if (((word >> 19) & 0x1) == 0)
5037                                                            {
5038                                                              /* 33222222222211111111110000000000
5039                                                                 10987654321098765432109876543210
5040                                                                 xxxxxxxxxxxxx1011010x0xx0x100000
5041                                                                 uxtw.  */
5042                                                              return 1955;
5043                                                            }
5044                                                          else
5045                                                            {
5046                                                              /* 33222222222211111111110000000000
5047                                                                 10987654321098765432109876543210
5048                                                                 xxxxxxxxxxxxx1011011x0xx0x100000
5049                                                                 fneg.  */
5050                                                              return 1410;
5051                                                            }
5052                                                        }
5053                                                    }
5054                                                  else
5055                                                    {
5056                                                      if (((word >> 18) & 0x1) == 0)
5057                                                        {
5058                                                          if (((word >> 19) & 0x1) == 0)
5059                                                            {
5060                                                              /* 33222222222211111111110000000000
5061                                                                 10987654321098765432109876543210
5062                                                                 xxxxxxxxxxxxx1011100x0xx0x100000
5063                                                                 uxth.  */
5064                                                              return 1954;
5065                                                            }
5066                                                          else
5067                                                            {
5068                                                              /* 33222222222211111111110000000000
5069                                                                 10987654321098765432109876543210
5070                                                                 xxxxxxxxxxxxx1011101x0xx0x100000
5071                                                                 cnot.  */
5072                                                              return 1299;
5073                                                            }
5074                                                        }
5075                                                      else
5076                                                        {
5077                                                          /* 33222222222211111111110000000000
5078                                                             10987654321098765432109876543210
5079                                                             xxxxxxxxxxxxx101111xx0xx0x100000
5080                                                             neg.  */
5081                                                          return 1688;
5082                                                        }
5083                                                    }
5084                                                }
5085                                            }
5086                                          else
5087                                            {
5088                                              if (((word >> 12) & 0x1) == 0)
5089                                                {
5090                                                  if (((word >> 23) & 0x1) == 0)
5091                                                    {
5092                                                      if (((word >> 22) & 0x1) == 0)
5093                                                        {
5094                                                          /* 33222222222211111111110000000000
5095                                                             10987654321098765432109876543210
5096                                                             xxxxxxxxxxxx0101xxxxx1000x100000
5097                                                             adr.  */
5098                                                          return 1235;
5099                                                        }
5100                                                      else
5101                                                        {
5102                                                          /* 33222222222211111111110000000000
5103                                                             10987654321098765432109876543210
5104                                                             xxxxxxxxxxxx0101xxxxx1100x100000
5105                                                             adr.  */
5106                                                          return 1236;
5107                                                        }
5108                                                    }
5109                                                  else
5110                                                    {
5111                                                      /* 33222222222211111111110000000000
5112                                                         10987654321098765432109876543210
5113                                                         xxxxxxxxxxxx0101xxxxx1x10x100000
5114                                                         adr.  */
5115                                                      return 1237;
5116                                                    }
5117                                                }
5118                                              else
5119                                                {
5120                                                  if (((word >> 10) & 0x1) == 0)
5121                                                    {
5122                                                      if (((word >> 11) & 0x1) == 0)
5123                                                        {
5124                                                          /* 33222222222211111111110000000000
5125                                                             10987654321098765432109876543210
5126                                                             xxxxxxxxxx001101xxxxx1xx0x100000
5127                                                             ftssel.  */
5128                                                          return 1436;
5129                                                        }
5130                                                      else
5131                                                        {
5132                                                          /* 33222222222211111111110000000000
5133                                                             10987654321098765432109876543210
5134                                                             xxxxxxxxxx011101xxxxx1xx0x100000
5135                                                             fexpa.  */
5136                                                          return 1380;
5137                                                        }
5138                                                    }
5139                                                  else
5140                                                    {
5141                                                      /* 33222222222211111111110000000000
5142                                                         10987654321098765432109876543210
5143                                                         xxxxxxxxxx1x1101xxxxx1xx0x100000
5144                                                         movprfx.  */
5145                                                      return 1681;
5146                                                    }
5147                                                }
5148                                            }
5149                                        }
5150                                      else
5151                                        {
5152                                          if (((word >> 22) & 0x1) == 0)
5153                                            {
5154                                              if (((word >> 23) & 0x1) == 0)
5155                                                {
5156                                                  /* 33222222222211111111110000000000
5157                                                     10987654321098765432109876543210
5158                                                     xxxxxxxxxxxxx101xxxxxx000x100001
5159                                                     ldff1sb.  */
5160                                                  return 1612;
5161                                                }
5162                                              else
5163                                                {
5164                                                  /* 33222222222211111111110000000000
5165                                                     10987654321098765432109876543210
5166                                                     xxxxxxxxxxxxx101xxxxxx010x100001
5167                                                     ldff1sh.  */
5168                                                  return 1622;
5169                                                }
5170                                            }
5171                                          else
5172                                            {
5173                                              if (((word >> 23) & 0x1) == 0)
5174                                                {
5175                                                  /* 33222222222211111111110000000000
5176                                                     10987654321098765432109876543210
5177                                                     xxxxxxxxxxxxx101xxxxxx100x100001
5178                                                     ld1rb.  */
5179                                                  return 1491;
5180                                                }
5181                                              else
5182                                                {
5183                                                  /* 33222222222211111111110000000000
5184                                                     10987654321098765432109876543210
5185                                                     xxxxxxxxxxxxx101xxxxxx110x100001
5186                                                     ld1rh.  */
5187                                                  return 1495;
5188                                                }
5189                                            }
5190                                        }
5191                                    }
5192                                  else
5193                                    {
5194                                      if (((word >> 21) & 0x1) == 0)
5195                                        {
5196                                          if (((word >> 23) & 0x1) == 0)
5197                                            {
5198                                              /* 33222222222211111111110000000000
5199                                                 10987654321098765432109876543210
5200                                                 xxxxxxxxxxxxx101xxxxx0x00x10001x
5201                                                 ldff1sb.  */
5202                                              return 1611;
5203                                            }
5204                                          else
5205                                            {
5206                                              /* 33222222222211111111110000000000
5207                                                 10987654321098765432109876543210
5208                                                 xxxxxxxxxxxxx101xxxxx0x10x10001x
5209                                                 ldff1sh.  */
5210                                              return 1620;
5211                                            }
5212                                        }
5213                                      else
5214                                        {
5215                                          if (((word >> 22) & 0x1) == 0)
5216                                            {
5217                                              if (((word >> 23) & 0x1) == 0)
5218                                                {
5219                                                  /* 33222222222211111111110000000000
5220                                                     10987654321098765432109876543210
5221                                                     xxxxxxxxxxxxx101xxxxx1000x10001x
5222                                                     ldff1sb.  */
5223                                                  return 1613;
5224                                                }
5225                                              else
5226                                                {
5227                                                  /* 33222222222211111111110000000000
5228                                                     10987654321098765432109876543210
5229                                                     xxxxxxxxxxxxx101xxxxx1010x10001x
5230                                                     ldff1sh.  */
5231                                                  return 1623;
5232                                                }
5233                                            }
5234                                          else
5235                                            {
5236                                              if (((word >> 23) & 0x1) == 0)
5237                                                {
5238                                                  /* 33222222222211111111110000000000
5239                                                     10987654321098765432109876543210
5240                                                     xxxxxxxxxxxxx101xxxxx1100x10001x
5241                                                     prfh.  */
5242                                                  return 1720;
5243                                                }
5244                                              else
5245                                                {
5246                                                  /* 33222222222211111111110000000000
5247                                                     10987654321098765432109876543210
5248                                                     xxxxxxxxxxxxx101xxxxx1110x10001x
5249                                                     ldff1sh.  */
5250                                                  return 1621;
5251                                                }
5252                                            }
5253                                        }
5254                                    }
5255                                }
5256                            }
5257                          else
5258                            {
5259                              if (((word >> 15) & 0x1) == 0)
5260                                {
5261                                  if (((word >> 21) & 0x1) == 0)
5262                                    {
5263                                      if (((word >> 30) & 0x1) == 0)
5264                                        {
5265                                          if (((word >> 31) & 0x1) == 0)
5266                                            {
5267                                              /* 33222222222211111111110000000000
5268                                                 10987654321098765432109876543210
5269                                                 xxxxxxxxxxxxx110xxxxx0xx0x100000
5270                                                 mls.  */
5271                                              return 1680;
5272                                            }
5273                                          else
5274                                            {
5275                                              if (((word >> 23) & 0x1) == 0)
5276                                                {
5277                                                  /* 33222222222211111111110000000000
5278                                                     10987654321098765432109876543210
5279                                                     xxxxxxxxxxxxx110xxxxx0x00x100001
5280                                                     ldff1b.  */
5281                                                  return 1580;
5282                                                }
5283                                              else
5284                                                {
5285                                                  /* 33222222222211111111110000000000
5286                                                     10987654321098765432109876543210
5287                                                     xxxxxxxxxxxxx110xxxxx0x10x100001
5288                                                     ldff1h.  */
5289                                                  return 1595;
5290                                                }
5291                                            }
5292                                        }
5293                                      else
5294                                        {
5295                                          if (((word >> 23) & 0x1) == 0)
5296                                            {
5297                                              /* 33222222222211111111110000000000
5298                                                 10987654321098765432109876543210
5299                                                 xxxxxxxxxxxxx110xxxxx0x00x10001x
5300                                                 ldff1b.  */
5301                                              return 1585;
5302                                            }
5303                                          else
5304                                            {
5305                                              /* 33222222222211111111110000000000
5306                                                 10987654321098765432109876543210
5307                                                 xxxxxxxxxxxxx110xxxxx0x10x10001x
5308                                                 ldff1h.  */
5309                                              return 1600;
5310                                            }
5311                                        }
5312                                    }
5313                                  else
5314                                    {
5315                                      if (((word >> 23) & 0x1) == 0)
5316                                        {
5317                                          if (((word >> 30) & 0x1) == 0)
5318                                            {
5319                                              /* 33222222222211111111110000000000
5320                                                 10987654321098765432109876543210
5321                                                 xxxxxxxxxxxxx110xxxxx1x00x10000x
5322                                                 prfd.  */
5323                                              return 1710;
5324                                            }
5325                                          else
5326                                            {
5327                                              /* 33222222222211111111110000000000
5328                                                 10987654321098765432109876543210
5329                                                 xxxxxxxxxxxxx110xxxxx1x00x10001x
5330                                                 prfd.  */
5331                                              return 1712;
5332                                            }
5333                                        }
5334                                      else
5335                                        {
5336                                          if (((word >> 30) & 0x1) == 0)
5337                                            {
5338                                              /* 33222222222211111111110000000000
5339                                                 10987654321098765432109876543210
5340                                                 xxxxxxxxxxxxx110xxxxx1x10x10000x
5341                                                 ldff1h.  */
5342                                              return 1596;
5343                                            }
5344                                          else
5345                                            {
5346                                              /* 33222222222211111111110000000000
5347                                                 10987654321098765432109876543210
5348                                                 xxxxxxxxxxxxx110xxxxx1x10x10001x
5349                                                 ldff1h.  */
5350                                              return 1601;
5351                                            }
5352                                        }
5353                                    }
5354                                }
5355                              else
5356                                {
5357                                  if (((word >> 30) & 0x1) == 0)
5358                                    {
5359                                      if (((word >> 31) & 0x1) == 0)
5360                                        {
5361                                          if (((word >> 21) & 0x1) == 0)
5362                                            {
5363                                              /* 33222222222211111111110000000000
5364                                                 10987654321098765432109876543210
5365                                                 xxxxxxxxxxxxx111xxxxx0xx0x100000
5366                                                 msb.  */
5367                                              return 1683;
5368                                            }
5369                                          else
5370                                            {
5371                                              if (((word >> 10) & 0x1) == 0)
5372                                                {
5373                                                  if (((word >> 11) & 0x1) == 0)
5374                                                    {
5375                                                      if (((word >> 12) & 0x1) == 0)
5376                                                        {
5377                                                          if (((word >> 20) & 0x1) == 0)
5378                                                            {
5379                                                              if (((word >> 22) & 0x1) == 0)
5380                                                                {
5381                                                                  if (((word >> 23) & 0x1) == 0)
5382                                                                    {
5383                                                                      /* 33222222222211111111110000000000
5384                                                                         10987654321098765432109876543210
5385                                                                         xxxxxxxxxx000111xxxx01000x100000
5386                                                                         cntb.  */
5387                                                                      return 1301;
5388                                                                    }
5389                                                                  else
5390                                                                    {
5391                                                                      /* 33222222222211111111110000000000
5392                                                                         10987654321098765432109876543210
5393                                                                         xxxxxxxxxx000111xxxx01010x100000
5394                                                                         cntw.  */
5395                                                                      return 1305;
5396                                                                    }
5397                                                                }
5398                                                              else
5399                                                                {
5400                                                                  if (((word >> 23) & 0x1) == 0)
5401                                                                    {
5402                                                                      /* 33222222222211111111110000000000
5403                                                                         10987654321098765432109876543210
5404                                                                         xxxxxxxxxx000111xxxx01100x100000
5405                                                                         cnth.  */
5406                                                                      return 1303;
5407                                                                    }
5408                                                                  else
5409                                                                    {
5410                                                                      /* 33222222222211111111110000000000
5411                                                                         10987654321098765432109876543210
5412                                                                         xxxxxxxxxx000111xxxx01110x100000
5413                                                                         cntd.  */
5414                                                                      return 1302;
5415                                                                    }
5416                                                                }
5417                                                            }
5418                                                          else
5419                                                            {
5420                                                              if (((word >> 22) & 0x1) == 0)
5421                                                                {
5422                                                                  if (((word >> 23) & 0x1) == 0)
5423                                                                    {
5424                                                                      /* 33222222222211111111110000000000
5425                                                                         10987654321098765432109876543210
5426                                                                         xxxxxxxxxx000111xxxx11000x100000
5427                                                                         incb.  */
5428                                                                      return 1437;
5429                                                                    }
5430                                                                  else
5431                                                                    {
5432                                                                      /* 33222222222211111111110000000000
5433                                                                         10987654321098765432109876543210
5434                                                                         xxxxxxxxxx000111xxxx11010x100000
5435                                                                         incw.  */
5436                                                                      return 1445;
5437                                                                    }
5438                                                                }
5439                                                              else
5440                                                                {
5441                                                                  if (((word >> 23) & 0x1) == 0)
5442                                                                    {
5443                                                                      /* 33222222222211111111110000000000
5444                                                                         10987654321098765432109876543210
5445                                                                         xxxxxxxxxx000111xxxx11100x100000
5446                                                                         inch.  */
5447                                                                      return 1441;
5448                                                                    }
5449                                                                  else
5450                                                                    {
5451                                                                      /* 33222222222211111111110000000000
5452                                                                         10987654321098765432109876543210
5453                                                                         xxxxxxxxxx000111xxxx11110x100000
5454                                                                         incd.  */
5455                                                                      return 1439;
5456                                                                    }
5457                                                                }
5458                                                            }
5459                                                        }
5460                                                      else
5461                                                        {
5462                                                          if (((word >> 20) & 0x1) == 0)
5463                                                            {
5464                                                              if (((word >> 22) & 0x1) == 0)
5465                                                                {
5466                                                                  if (((word >> 23) & 0x1) == 0)
5467                                                                    {
5468                                                                      /* 33222222222211111111110000000000
5469                                                                         10987654321098765432109876543210
5470                                                                         xxxxxxxxxx001111xxxx01000x100000
5471                                                                         sqincb.  */
5472                                                                      return 1788;
5473                                                                    }
5474                                                                  else
5475                                                                    {
5476                                                                      /* 33222222222211111111110000000000
5477                                                                         10987654321098765432109876543210
5478                                                                         xxxxxxxxxx001111xxxx01010x100000
5479                                                                         sqincw.  */
5480                                                                      return 1800;
5481                                                                    }
5482                                                                }
5483                                                              else
5484                                                                {
5485                                                                  if (((word >> 23) & 0x1) == 0)
5486                                                                    {
5487                                                                      /* 33222222222211111111110000000000
5488                                                                         10987654321098765432109876543210
5489                                                                         xxxxxxxxxx001111xxxx01100x100000
5490                                                                         sqinch.  */
5491                                                                      return 1794;
5492                                                                    }
5493                                                                  else
5494                                                                    {
5495                                                                      /* 33222222222211111111110000000000
5496                                                                         10987654321098765432109876543210
5497                                                                         xxxxxxxxxx001111xxxx01110x100000
5498                                                                         sqincd.  */
5499                                                                      return 1791;
5500                                                                    }
5501                                                                }
5502                                                            }
5503                                                          else
5504                                                            {
5505                                                              if (((word >> 22) & 0x1) == 0)
5506                                                                {
5507                                                                  if (((word >> 23) & 0x1) == 0)
5508                                                                    {
5509                                                                      /* 33222222222211111111110000000000
5510                                                                         10987654321098765432109876543210
5511                                                                         xxxxxxxxxx001111xxxx11000x100000
5512                                                                         sqincb.  */
5513                                                                      return 1787;
5514                                                                    }
5515                                                                  else
5516                                                                    {
5517                                                                      /* 33222222222211111111110000000000
5518                                                                         10987654321098765432109876543210
5519                                                                         xxxxxxxxxx001111xxxx11010x100000
5520                                                                         sqincw.  */
5521                                                                      return 1799;
5522                                                                    }
5523                                                                }
5524                                                              else
5525                                                                {
5526                                                                  if (((word >> 23) & 0x1) == 0)
5527                                                                    {
5528                                                                      /* 33222222222211111111110000000000
5529                                                                         10987654321098765432109876543210
5530                                                                         xxxxxxxxxx001111xxxx11100x100000
5531                                                                         sqinch.  */
5532                                                                      return 1793;
5533                                                                    }
5534                                                                  else
5535                                                                    {
5536                                                                      /* 33222222222211111111110000000000
5537                                                                         10987654321098765432109876543210
5538                                                                         xxxxxxxxxx001111xxxx11110x100000
5539                                                                         sqincd.  */
5540                                                                      return 1790;
5541                                                                    }
5542                                                                }
5543                                                            }
5544                                                        }
5545                                                    }
5546                                                  else
5547                                                    {
5548                                                      if (((word >> 20) & 0x1) == 0)
5549                                                        {
5550                                                          if (((word >> 22) & 0x1) == 0)
5551                                                            {
5552                                                              if (((word >> 23) & 0x1) == 0)
5553                                                                {
5554                                                                  /* 33222222222211111111110000000000
5555                                                                     10987654321098765432109876543210
5556                                                                     xxxxxxxxxx01x111xxxx01000x100000
5557                                                                     sqdecb.  */
5558                                                                  return 1774;
5559                                                                }
5560                                                              else
5561                                                                {
5562                                                                  /* 33222222222211111111110000000000
5563                                                                     10987654321098765432109876543210
5564                                                                     xxxxxxxxxx01x111xxxx01010x100000
5565                                                                     sqdecw.  */
5566                                                                  return 1786;
5567                                                                }
5568                                                            }
5569                                                          else
5570                                                            {
5571                                                              if (((word >> 23) & 0x1) == 0)
5572                                                                {
5573                                                                  /* 33222222222211111111110000000000
5574                                                                     10987654321098765432109876543210
5575                                                                     xxxxxxxxxx01x111xxxx01100x100000
5576                                                                     sqdech.  */
5577                                                                  return 1780;
5578                                                                }
5579                                                              else
5580                                                                {
5581                                                                  /* 33222222222211111111110000000000
5582                                                                     10987654321098765432109876543210
5583                                                                     xxxxxxxxxx01x111xxxx01110x100000
5584                                                                     sqdecd.  */
5585                                                                  return 1777;
5586                                                                }
5587                                                            }
5588                                                        }
5589                                                      else
5590                                                        {
5591                                                          if (((word >> 22) & 0x1) == 0)
5592                                                            {
5593                                                              if (((word >> 23) & 0x1) == 0)
5594                                                                {
5595                                                                  /* 33222222222211111111110000000000
5596                                                                     10987654321098765432109876543210
5597                                                                     xxxxxxxxxx01x111xxxx11000x100000
5598                                                                     sqdecb.  */
5599                                                                  return 1773;
5600                                                                }
5601                                                              else
5602                                                                {
5603                                                                  /* 33222222222211111111110000000000
5604                                                                     10987654321098765432109876543210
5605                                                                     xxxxxxxxxx01x111xxxx11010x100000
5606                                                                     sqdecw.  */
5607                                                                  return 1785;
5608                                                                }
5609                                                            }
5610                                                          else
5611                                                            {
5612                                                              if (((word >> 23) & 0x1) == 0)
5613                                                                {
5614                                                                  /* 33222222222211111111110000000000
5615                                                                     10987654321098765432109876543210
5616                                                                     xxxxxxxxxx01x111xxxx11100x100000
5617                                                                     sqdech.  */
5618                                                                  return 1779;
5619                                                                }
5620                                                              else
5621                                                                {
5622                                                                  /* 33222222222211111111110000000000
5623                                                                     10987654321098765432109876543210
5624                                                                     xxxxxxxxxx01x111xxxx11110x100000
5625                                                                     sqdecd.  */
5626                                                                  return 1776;
5627                                                                }
5628                                                            }
5629                                                        }
5630                                                    }
5631                                                }
5632                                              else
5633                                                {
5634                                                  if (((word >> 11) & 0x1) == 0)
5635                                                    {
5636                                                      if (((word >> 12) & 0x1) == 0)
5637                                                        {
5638                                                          if (((word >> 22) & 0x1) == 0)
5639                                                            {
5640                                                              if (((word >> 23) & 0x1) == 0)
5641                                                                {
5642                                                                  /* 33222222222211111111110000000000
5643                                                                     10987654321098765432109876543210
5644                                                                     xxxxxxxxxx100111xxxxx1000x100000
5645                                                                     decb.  */
5646                                                                  return 1312;
5647                                                                }
5648                                                              else
5649                                                                {
5650                                                                  /* 33222222222211111111110000000000
5651                                                                     10987654321098765432109876543210
5652                                                                     xxxxxxxxxx100111xxxxx1010x100000
5653                                                                     decw.  */
5654                                                                  return 1320;
5655                                                                }
5656                                                            }
5657                                                          else
5658                                                            {
5659                                                              if (((word >> 23) & 0x1) == 0)
5660                                                                {
5661                                                                  /* 33222222222211111111110000000000
5662                                                                     10987654321098765432109876543210
5663                                                                     xxxxxxxxxx100111xxxxx1100x100000
5664                                                                     dech.  */
5665                                                                  return 1316;
5666                                                                }
5667                                                              else
5668                                                                {
5669                                                                  /* 33222222222211111111110000000000
5670                                                                     10987654321098765432109876543210
5671                                                                     xxxxxxxxxx100111xxxxx1110x100000
5672                                                                     decd.  */
5673                                                                  return 1314;
5674                                                                }
5675                                                            }
5676                                                        }
5677                                                      else
5678                                                        {
5679                                                          if (((word >> 20) & 0x1) == 0)
5680                                                            {
5681                                                              if (((word >> 22) & 0x1) == 0)
5682                                                                {
5683                                                                  if (((word >> 23) & 0x1) == 0)
5684                                                                    {
5685                                                                      /* 33222222222211111111110000000000
5686                                                                         10987654321098765432109876543210
5687                                                                         xxxxxxxxxx101111xxxx01000x100000
5688                                                                         uqincb.  */
5689                                                                      return 1935;
5690                                                                    }
5691                                                                  else
5692                                                                    {
5693                                                                      /* 33222222222211111111110000000000
5694                                                                         10987654321098765432109876543210
5695                                                                         xxxxxxxxxx101111xxxx01010x100000
5696                                                                         uqincw.  */
5697                                                                      return 1947;
5698                                                                    }
5699                                                                }
5700                                                              else
5701                                                                {
5702                                                                  if (((word >> 23) & 0x1) == 0)
5703                                                                    {
5704                                                                      /* 33222222222211111111110000000000
5705                                                                         10987654321098765432109876543210
5706                                                                         xxxxxxxxxx101111xxxx01100x100000
5707                                                                         uqinch.  */
5708                                                                      return 1941;
5709                                                                    }
5710                                                                  else
5711                                                                    {
5712                                                                      /* 33222222222211111111110000000000
5713                                                                         10987654321098765432109876543210
5714                                                                         xxxxxxxxxx101111xxxx01110x100000
5715                                                                         uqincd.  */
5716                                                                      return 1938;
5717                                                                    }
5718                                                                }
5719                                                            }
5720                                                          else
5721                                                            {
5722                                                              if (((word >> 22) & 0x1) == 0)
5723                                                                {
5724                                                                  if (((word >> 23) & 0x1) == 0)
5725                                                                    {
5726                                                                      /* 33222222222211111111110000000000
5727                                                                         10987654321098765432109876543210
5728                                                                         xxxxxxxxxx101111xxxx11000x100000
5729                                                                         uqincb.  */
5730                                                                      return 1936;
5731                                                                    }
5732                                                                  else
5733                                                                    {
5734                                                                      /* 33222222222211111111110000000000
5735                                                                         10987654321098765432109876543210
5736                                                                         xxxxxxxxxx101111xxxx11010x100000
5737                                                                         uqincw.  */
5738                                                                      return 1948;
5739                                                                    }
5740                                                                }
5741                                                              else
5742                                                                {
5743                                                                  if (((word >> 23) & 0x1) == 0)
5744                                                                    {
5745                                                                      /* 33222222222211111111110000000000
5746                                                                         10987654321098765432109876543210
5747                                                                         xxxxxxxxxx101111xxxx11100x100000
5748                                                                         uqinch.  */
5749                                                                      return 1942;
5750                                                                    }
5751                                                                  else
5752                                                                    {
5753                                                                      /* 33222222222211111111110000000000
5754                                                                         10987654321098765432109876543210
5755                                                                         xxxxxxxxxx101111xxxx11110x100000
5756                                                                         uqincd.  */
5757                                                                      return 1939;
5758                                                                    }
5759                                                                }
5760                                                            }
5761                                                        }
5762                                                    }
5763                                                  else
5764                                                    {
5765                                                      if (((word >> 20) & 0x1) == 0)
5766                                                        {
5767                                                          if (((word >> 22) & 0x1) == 0)
5768                                                            {
5769                                                              if (((word >> 23) & 0x1) == 0)
5770                                                                {
5771                                                                  /* 33222222222211111111110000000000
5772                                                                     10987654321098765432109876543210
5773                                                                     xxxxxxxxxx11x111xxxx01000x100000
5774                                                                     uqdecb.  */
5775                                                                  return 1921;
5776                                                                }
5777                                                              else
5778                                                                {
5779                                                                  /* 33222222222211111111110000000000
5780                                                                     10987654321098765432109876543210
5781                                                                     xxxxxxxxxx11x111xxxx01010x100000
5782                                                                     uqdecw.  */
5783                                                                  return 1933;
5784                                                                }
5785                                                            }
5786                                                          else
5787                                                            {
5788                                                              if (((word >> 23) & 0x1) == 0)
5789                                                                {
5790                                                                  /* 33222222222211111111110000000000
5791                                                                     10987654321098765432109876543210
5792                                                                     xxxxxxxxxx11x111xxxx01100x100000
5793                                                                     uqdech.  */
5794                                                                  return 1927;
5795                                                                }
5796                                                              else
5797                                                                {
5798                                                                  /* 33222222222211111111110000000000
5799                                                                     10987654321098765432109876543210
5800                                                                     xxxxxxxxxx11x111xxxx01110x100000
5801                                                                     uqdecd.  */
5802                                                                  return 1924;
5803                                                                }
5804                                                            }
5805                                                        }
5806                                                      else
5807                                                        {
5808                                                          if (((word >> 22) & 0x1) == 0)
5809                                                            {
5810                                                              if (((word >> 23) & 0x1) == 0)
5811                                                                {
5812                                                                  /* 33222222222211111111110000000000
5813                                                                     10987654321098765432109876543210
5814                                                                     xxxxxxxxxx11x111xxxx11000x100000
5815                                                                     uqdecb.  */
5816                                                                  return 1922;
5817                                                                }
5818                                                              else
5819                                                                {
5820                                                                  /* 33222222222211111111110000000000
5821                                                                     10987654321098765432109876543210
5822                                                                     xxxxxxxxxx11x111xxxx11010x100000
5823                                                                     uqdecw.  */
5824                                                                  return 1934;
5825                                                                }
5826                                                            }
5827                                                          else
5828                                                            {
5829                                                              if (((word >> 23) & 0x1) == 0)
5830                                                                {
5831                                                                  /* 33222222222211111111110000000000
5832                                                                     10987654321098765432109876543210
5833                                                                     xxxxxxxxxx11x111xxxx11100x100000
5834                                                                     uqdech.  */
5835                                                                  return 1928;
5836                                                                }
5837                                                              else
5838                                                                {
5839                                                                  /* 33222222222211111111110000000000
5840                                                                     10987654321098765432109876543210
5841                                                                     xxxxxxxxxx11x111xxxx11110x100000
5842                                                                     uqdecd.  */
5843                                                                  return 1925;
5844                                                                }
5845                                                            }
5846                                                        }
5847                                                    }
5848                                                }
5849                                            }
5850                                        }
5851                                      else
5852                                        {
5853                                          if (((word >> 22) & 0x1) == 0)
5854                                            {
5855                                              if (((word >> 21) & 0x1) == 0)
5856                                                {
5857                                                  if (((word >> 23) & 0x1) == 0)
5858                                                    {
5859                                                      /* 33222222222211111111110000000000
5860                                                         10987654321098765432109876543210
5861                                                         xxxxxxxxxxxxx111xxxxx0000x100001
5862                                                         prfb.  */
5863                                                      return 1707;
5864                                                    }
5865                                                  else
5866                                                    {
5867                                                      /* 33222222222211111111110000000000
5868                                                         10987654321098765432109876543210
5869                                                         xxxxxxxxxxxxx111xxxxx0010x100001
5870                                                         prfh.  */
5871                                                      return 1721;
5872                                                    }
5873                                                }
5874                                              else
5875                                                {
5876                                                  if (((word >> 23) & 0x1) == 0)
5877                                                    {
5878                                                      /* 33222222222211111111110000000000
5879                                                         10987654321098765432109876543210
5880                                                         xxxxxxxxxxxxx111xxxxx1000x100001
5881                                                         ldff1b.  */
5882                                                      return 1587;
5883                                                    }
5884                                                  else
5885                                                    {
5886                                                      /* 33222222222211111111110000000000
5887                                                         10987654321098765432109876543210
5888                                                         xxxxxxxxxxxxx111xxxxx1010x100001
5889                                                         ldff1h.  */
5890                                                      return 1604;
5891                                                    }
5892                                                }
5893                                            }
5894                                          else
5895                                            {
5896                                              if (((word >> 23) & 0x1) == 0)
5897                                                {
5898                                                  /* 33222222222211111111110000000000
5899                                                     10987654321098765432109876543210
5900                                                     xxxxxxxxxxxxx111xxxxxx100x100001
5901                                                     ld1rb.  */
5902                                                  return 1493;
5903                                                }
5904                                              else
5905                                                {
5906                                                  /* 33222222222211111111110000000000
5907                                                     10987654321098765432109876543210
5908                                                     xxxxxxxxxxxxx111xxxxxx110x100001
5909                                                     ld1rh.  */
5910                                                  return 1497;
5911                                                }
5912                                            }
5913                                        }
5914                                    }
5915                                  else
5916                                    {
5917                                      if (((word >> 21) & 0x1) == 0)
5918                                        {
5919                                          if (((word >> 22) & 0x1) == 0)
5920                                            {
5921                                              if (((word >> 23) & 0x1) == 0)
5922                                                {
5923                                                  /* 33222222222211111111110000000000
5924                                                     10987654321098765432109876543210
5925                                                     xxxxxxxxxxxxx111xxxxx0000x10001x
5926                                                     prfb.  */
5927                                                  return 1709;
5928                                                }
5929                                              else
5930                                                {
5931                                                  /* 33222222222211111111110000000000
5932                                                     10987654321098765432109876543210
5933                                                     xxxxxxxxxxxxx111xxxxx0010x10001x
5934                                                     prfh.  */
5935                                                  return 1723;
5936                                                }
5937                                            }
5938                                          else
5939                                            {
5940                                              if (((word >> 23) & 0x1) == 0)
5941                                                {
5942                                                  /* 33222222222211111111110000000000
5943                                                     10987654321098765432109876543210
5944                                                     xxxxxxxxxxxxx111xxxxx0100x10001x
5945                                                     ldff1b.  */
5946                                                  return 1586;
5947                                                }
5948                                              else
5949                                                {
5950                                                  /* 33222222222211111111110000000000
5951                                                     10987654321098765432109876543210
5952                                                     xxxxxxxxxxxxx111xxxxx0110x10001x
5953                                                     ldff1h.  */
5954                                                  return 1602;
5955                                                }
5956                                            }
5957                                        }
5958                                      else
5959                                        {
5960                                          if (((word >> 22) & 0x1) == 0)
5961                                            {
5962                                              if (((word >> 23) & 0x1) == 0)
5963                                                {
5964                                                  /* 33222222222211111111110000000000
5965                                                     10987654321098765432109876543210
5966                                                     xxxxxxxxxxxxx111xxxxx1000x10001x
5967                                                     ldff1b.  */
5968                                                  return 1588;
5969                                                }
5970                                              else
5971                                                {
5972                                                  /* 33222222222211111111110000000000
5973                                                     10987654321098765432109876543210
5974                                                     xxxxxxxxxxxxx111xxxxx1010x10001x
5975                                                     ldff1h.  */
5976                                                  return 1605;
5977                                                }
5978                                            }
5979                                          else
5980                                            {
5981                                              if (((word >> 23) & 0x1) == 0)
5982                                                {
5983                                                  /* 33222222222211111111110000000000
5984                                                     10987654321098765432109876543210
5985                                                     xxxxxxxxxxxxx111xxxxx1100x10001x
5986                                                     prfd.  */
5987                                                  return 1713;
5988                                                }
5989                                              else
5990                                                {
5991                                                  /* 33222222222211111111110000000000
5992                                                     10987654321098765432109876543210
5993                                                     xxxxxxxxxxxxx111xxxxx1110x10001x
5994                                                     ldff1h.  */
5995                                                  return 1603;
5996                                                }
5997                                            }
5998                                        }
5999                                    }
6000                                }
6001                            }
6002                        }
6003                    }
6004                  else
6005                    {
6006                      if (((word >> 21) & 0x1) == 0)
6007                        {
6008                          if (((word >> 15) & 0x1) == 0)
6009                            {
6010                              if (((word >> 30) & 0x1) == 0)
6011                                {
6012                                  if (((word >> 13) & 0x1) == 0)
6013                                    {
6014                                      if (((word >> 14) & 0x1) == 0)
6015                                        {
6016                                          if (((word >> 31) & 0x1) == 0)
6017                                            {
6018                                              if (((word >> 4) & 0x1) == 0)
6019                                                {
6020                                                  /* 33222222222211111111110000000000
6021                                                     10987654321098765432109876543210
6022                                                     xxxx0xxxxxxxx000xxxxx0xx0x100100
6023                                                     cmphs.  */
6024                                                  return 1285;
6025                                                }
6026                                              else
6027                                                {
6028                                                  /* 33222222222211111111110000000000
6029                                                     10987654321098765432109876543210
6030                                                     xxxx1xxxxxxxx000xxxxx0xx0x100100
6031                                                     cmphi.  */
6032                                                  return 1282;
6033                                                }
6034                                            }
6035                                          else
6036                                            {
6037                                              if (((word >> 23) & 0x1) == 0)
6038                                                {
6039                                                  /* 33222222222211111111110000000000
6040                                                     10987654321098765432109876543210
6041                                                     xxxxxxxxxxxxx000xxxxx0x00x100101
6042                                                     ld1rqb.  */
6043                                                  return 1499;
6044                                                }
6045                                              else
6046                                                {
6047                                                  /* 33222222222211111111110000000000
6048                                                     10987654321098765432109876543210
6049                                                     xxxxxxxxxxxxx000xxxxx0x10x100101
6050                                                     ld1rqh.  */
6051                                                  return 1503;
6052                                                }
6053                                            }
6054                                        }
6055                                      else
6056                                        {
6057                                          if (((word >> 31) & 0x1) == 0)
6058                                            {
6059                                              if (((word >> 4) & 0x1) == 0)
6060                                                {
6061                                                  /* 33222222222211111111110000000000
6062                                                     10987654321098765432109876543210
6063                                                     xxxx0xxxxxxxx010xxxxx0xx0x100100
6064                                                     cmpge.  */
6065                                                  return 1276;
6066                                                }
6067                                              else
6068                                                {
6069                                                  /* 33222222222211111111110000000000
6070                                                     10987654321098765432109876543210
6071                                                     xxxx1xxxxxxxx010xxxxx0xx0x100100
6072                                                     cmpgt.  */
6073                                                  return 1279;
6074                                                }
6075                                            }
6076                                          else
6077                                            {
6078                                              if (((word >> 22) & 0x1) == 0)
6079                                                {
6080                                                  if (((word >> 23) & 0x1) == 0)
6081                                                    {
6082                                                      /* 33222222222211111111110000000000
6083                                                         10987654321098765432109876543210
6084                                                         xxxxxxxxxxxxx010xxxxx0000x100101
6085                                                         ld1b.  */
6086                                                      return 1457;
6087                                                    }
6088                                                  else
6089                                                    {
6090                                                      /* 33222222222211111111110000000000
6091                                                         10987654321098765432109876543210
6092                                                         xxxxxxxxxxxxx010xxxxx0010x100101
6093                                                         ld1sw.  */
6094                                                      return 1537;
6095                                                    }
6096                                                }
6097                                              else
6098                                                {
6099                                                  if (((word >> 23) & 0x1) == 0)
6100                                                    {
6101                                                      /* 33222222222211111111110000000000
6102                                                         10987654321098765432109876543210
6103                                                         xxxxxxxxxxxxx010xxxxx0100x100101
6104                                                         ld1b.  */
6105                                                      return 1459;
6106                                                    }
6107                                                  else
6108                                                    {
6109                                                      /* 33222222222211111111110000000000
6110                                                         10987654321098765432109876543210
6111                                                         xxxxxxxxxxxxx010xxxxx0110x100101
6112                                                         ld1h.  */
6113                                                      return 1479;
6114                                                    }
6115                                                }
6116                                            }
6117                                        }
6118                                    }
6119                                  else
6120                                    {
6121                                      if (((word >> 14) & 0x1) == 0)
6122                                        {
6123                                          if (((word >> 31) & 0x1) == 0)
6124                                            {
6125                                              if (((word >> 4) & 0x1) == 0)
6126                                                {
6127                                                  /* 33222222222211111111110000000000
6128                                                     10987654321098765432109876543210
6129                                                     xxxx0xxxxxxxx100xxxxx0xx0x100100
6130                                                     cmpeq.  */
6131                                                  return 1273;
6132                                                }
6133                                              else
6134                                                {
6135                                                  /* 33222222222211111111110000000000
6136                                                     10987654321098765432109876543210
6137                                                     xxxx1xxxxxxxx100xxxxx0xx0x100100
6138                                                     cmpne.  */
6139                                                  return 1296;
6140                                                }
6141                                            }
6142                                          else
6143                                            {
6144                                              if (((word >> 23) & 0x1) == 0)
6145                                                {
6146                                                  /* 33222222222211111111110000000000
6147                                                     10987654321098765432109876543210
6148                                                     xxxxxxxxxxxxx100xxxxx0x00x100101
6149                                                     ld1rqb.  */
6150                                                  return 1498;
6151                                                }
6152                                              else
6153                                                {
6154                                                  /* 33222222222211111111110000000000
6155                                                     10987654321098765432109876543210
6156                                                     xxxxxxxxxxxxx100xxxxx0x10x100101
6157                                                     ld1rqh.  */
6158                                                  return 1502;
6159                                                }
6160                                            }
6161                                        }
6162                                      else
6163                                        {
6164                                          if (((word >> 31) & 0x1) == 0)
6165                                            {
6166                                              if (((word >> 4) & 0x1) == 0)
6167                                                {
6168                                                  /* 33222222222211111111110000000000
6169                                                     10987654321098765432109876543210
6170                                                     xxxx0xxxxxxxx110xxxxx0xx0x100100
6171                                                     cmplt.  */
6172                                                  return 1294;
6173                                                }
6174                                              else
6175                                                {
6176                                                  /* 33222222222211111111110000000000
6177                                                     10987654321098765432109876543210
6178                                                     xxxx1xxxxxxxx110xxxxx0xx0x100100
6179                                                     cmple.  */
6180                                                  return 1288;
6181                                                }
6182                                            }
6183                                          else
6184                                            {
6185                                              if (((word >> 22) & 0x1) == 0)
6186                                                {
6187                                                  if (((word >> 23) & 0x1) == 0)
6188                                                    {
6189                                                      /* 33222222222211111111110000000000
6190                                                         10987654321098765432109876543210
6191                                                         xxxxxxxxxxxxx110xxxxx0000x100101
6192                                                         ldff1b.  */
6193                                                      return 1581;
6194                                                    }
6195                                                  else
6196                                                    {
6197                                                      /* 33222222222211111111110000000000
6198                                                         10987654321098765432109876543210
6199                                                         xxxxxxxxxxxxx110xxxxx0010x100101
6200                                                         ldff1sw.  */
6201                                                      return 1624;
6202                                                    }
6203                                                }
6204                                              else
6205                                                {
6206                                                  if (((word >> 23) & 0x1) == 0)
6207                                                    {
6208                                                      /* 33222222222211111111110000000000
6209                                                         10987654321098765432109876543210
6210                                                         xxxxxxxxxxxxx110xxxxx0100x100101
6211                                                         ldff1b.  */
6212                                                      return 1583;
6213                                                    }
6214                                                  else
6215                                                    {
6216                                                      /* 33222222222211111111110000000000
6217                                                         10987654321098765432109876543210
6218                                                         xxxxxxxxxxxxx110xxxxx0110x100101
6219                                                         ldff1h.  */
6220                                                      return 1598;
6221                                                    }
6222                                                }
6223                                            }
6224                                        }
6225                                    }
6226                                }
6227                              else
6228                                {
6229                                  if (((word >> 31) & 0x1) == 0)
6230                                    {
6231                                      /* 33222222222211111111110000000000
6232                                         10987654321098765432109876543210
6233                                         xxxxxxxxxxxxxxx0xxxxx0xx0x100110
6234                                         fcmla.  */
6235                                      return 1342;
6236                                    }
6237                                  else
6238                                    {
6239                                      if (((word >> 13) & 0x1) == 0)
6240                                        {
6241                                          if (((word >> 22) & 0x1) == 0)
6242                                            {
6243                                              /* 33222222222211111111110000000000
6244                                                 10987654321098765432109876543210
6245                                                 xxxxxxxxxxxxx0x0xxxxx00x0x100111
6246                                                 st1b.  */
6247                                              return 1803;
6248                                            }
6249                                          else
6250                                            {
6251                                              if (((word >> 23) & 0x1) == 0)
6252                                                {
6253                                                  /* 33222222222211111111110000000000
6254                                                     10987654321098765432109876543210
6255                                                     xxxxxxxxxxxxx0x0xxxxx0100x100111
6256                                                     st1b.  */
6257                                                  return 1807;
6258                                                }
6259                                              else
6260                                                {
6261                                                  /* 33222222222211111111110000000000
6262                                                     10987654321098765432109876543210
6263                                                     xxxxxxxxxxxxx0x0xxxxx0110x100111
6264                                                     st1h.  */
6265                                                  return 1828;
6266                                                }
6267                                            }
6268                                        }
6269                                      else
6270                                        {
6271                                          if (((word >> 22) & 0x1) == 0)
6272                                            {
6273                                              if (((word >> 23) & 0x1) == 0)
6274                                                {
6275                                                  /* 33222222222211111111110000000000
6276                                                     10987654321098765432109876543210
6277                                                     xxxxxxxxxxxxx1x0xxxxx0000x100111
6278                                                     stnt1b.  */
6279                                                  return 1873;
6280                                                }
6281                                              else
6282                                                {
6283                                                  /* 33222222222211111111110000000000
6284                                                     10987654321098765432109876543210
6285                                                     xxxxxxxxxxxxx1x0xxxxx0010x100111
6286                                                     stnt1h.  */
6287                                                  return 1877;
6288                                                }
6289                                            }
6290                                          else
6291                                            {
6292                                              if (((word >> 23) & 0x1) == 0)
6293                                                {
6294                                                  /* 33222222222211111111110000000000
6295                                                     10987654321098765432109876543210
6296                                                     xxxxxxxxxxxxx1x0xxxxx0100x100111
6297                                                     st3b.  */
6298                                                  return 1857;
6299                                                }
6300                                              else
6301                                                {
6302                                                  /* 33222222222211111111110000000000
6303                                                     10987654321098765432109876543210
6304                                                     xxxxxxxxxxxxx1x0xxxxx0110x100111
6305                                                     st3h.  */
6306                                                  return 1861;
6307                                                }
6308                                            }
6309                                        }
6310                                    }
6311                                }
6312                            }
6313                          else
6314                            {
6315                              if (((word >> 13) & 0x1) == 0)
6316                                {
6317                                  if (((word >> 30) & 0x1) == 0)
6318                                    {
6319                                      if (((word >> 14) & 0x1) == 0)
6320                                        {
6321                                          if (((word >> 4) & 0x1) == 0)
6322                                            {
6323                                              /* 33222222222211111111110000000000
6324                                                 10987654321098765432109876543210
6325                                                 xxxx0xxxxxxxx001xxxxx0xx0x10010x
6326                                                 cmpge.  */
6327                                              return 1277;
6328                                            }
6329                                          else
6330                                            {
6331                                              /* 33222222222211111111110000000000
6332                                                 10987654321098765432109876543210
6333                                                 xxxx1xxxxxxxx001xxxxx0xx0x10010x
6334                                                 cmpgt.  */
6335                                              return 1280;
6336                                            }
6337                                        }
6338                                      else
6339                                        {
6340                                          if (((word >> 31) & 0x1) == 0)
6341                                            {
6342                                              if (((word >> 4) & 0x1) == 0)
6343                                                {
6344                                                  /* 33222222222211111111110000000000
6345                                                     10987654321098765432109876543210
6346                                                     xxxx0xxxxxxxx011xxxxx0xx0x100100
6347                                                     cmphs.  */
6348                                                  return 1286;
6349                                                }
6350                                              else
6351                                                {
6352                                                  /* 33222222222211111111110000000000
6353                                                     10987654321098765432109876543210
6354                                                     xxxx1xxxxxxxx011xxxxx0xx0x100100
6355                                                     cmphi.  */
6356                                                  return 1283;
6357                                                }
6358                                            }
6359                                          else
6360                                            {
6361                                              if (((word >> 22) & 0x1) == 0)
6362                                                {
6363                                                  if (((word >> 23) & 0x1) == 0)
6364                                                    {
6365                                                      /* 33222222222211111111110000000000
6366                                                         10987654321098765432109876543210
6367                                                         xxxxxxxxxxxxx011xxxxx0000x100101
6368                                                         ldnt1b.  */
6369                                                      return 1656;
6370                                                    }
6371                                                  else
6372                                                    {
6373                                                      /* 33222222222211111111110000000000
6374                                                         10987654321098765432109876543210
6375                                                         xxxxxxxxxxxxx011xxxxx0010x100101
6376                                                         ldnt1h.  */
6377                                                      return 1660;
6378                                                    }
6379                                                }
6380                                              else
6381                                                {
6382                                                  if (((word >> 23) & 0x1) == 0)
6383                                                    {
6384                                                      /* 33222222222211111111110000000000
6385                                                         10987654321098765432109876543210
6386                                                         xxxxxxxxxxxxx011xxxxx0100x100101
6387                                                         ld3b.  */
6388                                                      return 1564;
6389                                                    }
6390                                                  else
6391                                                    {
6392                                                      /* 33222222222211111111110000000000
6393                                                         10987654321098765432109876543210
6394                                                         xxxxxxxxxxxxx011xxxxx0110x100101
6395                                                         ld3h.  */
6396                                                      return 1568;
6397                                                    }
6398                                                }
6399                                            }
6400                                        }
6401                                    }
6402                                  else
6403                                    {
6404                                      if (((word >> 31) & 0x1) == 0)
6405                                        {
6406                                          /* 33222222222211111111110000000000
6407                                             10987654321098765432109876543210
6408                                             xxxxxxxxxxxxx0x1xxxxx0xx0x100110
6409                                             fcadd.  */
6410                                          return 1341;
6411                                        }
6412                                      else
6413                                        {
6414                                          if (((word >> 22) & 0x1) == 0)
6415                                            {
6416                                              if (((word >> 23) & 0x1) == 0)
6417                                                {
6418                                                  /* 33222222222211111111110000000000
6419                                                     10987654321098765432109876543210
6420                                                     xxxxxxxxxxxxx0x1xxxxx0000x100111
6421                                                     st1b.  */
6422                                                  return 1804;
6423                                                }
6424                                              else
6425                                                {
6426                                                  /* 33222222222211111111110000000000
6427                                                     10987654321098765432109876543210
6428                                                     xxxxxxxxxxxxx0x1xxxxx0010x100111
6429                                                     st1h.  */
6430                                                  return 1823;
6431                                                }
6432                                            }
6433                                          else
6434                                            {
6435                                              if (((word >> 23) & 0x1) == 0)
6436                                                {
6437                                                  /* 33222222222211111111110000000000
6438                                                     10987654321098765432109876543210
6439                                                     xxxxxxxxxxxxx0x1xxxxx0100x100111
6440                                                     st1b.  */
6441                                                  return 1808;
6442                                                }
6443                                              else
6444                                                {
6445                                                  /* 33222222222211111111110000000000
6446                                                     10987654321098765432109876543210
6447                                                     xxxxxxxxxxxxx0x1xxxxx0110x100111
6448                                                     st1h.  */
6449                                                  return 1829;
6450                                                }
6451                                            }
6452                                        }
6453                                    }
6454                                }
6455                              else
6456                                {
6457                                  if (((word >> 14) & 0x1) == 0)
6458                                    {
6459                                      if (((word >> 30) & 0x1) == 0)
6460                                        {
6461                                          if (((word >> 31) & 0x1) == 0)
6462                                            {
6463                                              if (((word >> 4) & 0x1) == 0)
6464                                                {
6465                                                  /* 33222222222211111111110000000000
6466                                                     10987654321098765432109876543210
6467                                                     xxxx0xxxxxxxx101xxxxx0xx0x100100
6468                                                     cmpeq.  */
6469                                                  return 1274;
6470                                                }
6471                                              else
6472                                                {
6473                                                  /* 33222222222211111111110000000000
6474                                                     10987654321098765432109876543210
6475                                                     xxxx1xxxxxxxx101xxxxx0xx0x100100
6476                                                     cmpne.  */
6477                                                  return 1297;
6478                                                }
6479                                            }
6480                                          else
6481                                            {
6482                                              if (((word >> 20) & 0x1) == 0)
6483                                                {
6484                                                  if (((word >> 22) & 0x1) == 0)
6485                                                    {
6486                                                      if (((word >> 23) & 0x1) == 0)
6487                                                        {
6488                                                          /* 33222222222211111111110000000000
6489                                                             10987654321098765432109876543210
6490                                                             xxxxxxxxxxxxx101xxxx00000x100101
6491                                                             ld1b.  */
6492                                                          return 1464;
6493                                                        }
6494                                                      else
6495                                                        {
6496                                                          /* 33222222222211111111110000000000
6497                                                             10987654321098765432109876543210
6498                                                             xxxxxxxxxxxxx101xxxx00010x100101
6499                                                             ld1sw.  */
6500                                                          return 1542;
6501                                                        }
6502                                                    }
6503                                                  else
6504                                                    {
6505                                                      if (((word >> 23) & 0x1) == 0)
6506                                                        {
6507                                                          /* 33222222222211111111110000000000
6508                                                             10987654321098765432109876543210
6509                                                             xxxxxxxxxxxxx101xxxx00100x100101
6510                                                             ld1b.  */
6511                                                          return 1466;
6512                                                        }
6513                                                      else
6514                                                        {
6515                                                          /* 33222222222211111111110000000000
6516                                                             10987654321098765432109876543210
6517                                                             xxxxxxxxxxxxx101xxxx00110x100101
6518                                                             ld1h.  */
6519                                                          return 1487;
6520                                                        }
6521                                                    }
6522                                                }
6523                                              else
6524                                                {
6525                                                  if (((word >> 22) & 0x1) == 0)
6526                                                    {
6527                                                      if (((word >> 23) & 0x1) == 0)
6528                                                        {
6529                                                          /* 33222222222211111111110000000000
6530                                                             10987654321098765432109876543210
6531                                                             xxxxxxxxxxxxx101xxxx10000x100101
6532                                                             ldnf1b.  */
6533                                                          return 1640;
6534                                                        }
6535                                                      else
6536                                                        {
6537                                                          /* 33222222222211111111110000000000
6538                                                             10987654321098765432109876543210
6539                                                             xxxxxxxxxxxxx101xxxx10010x100101
6540                                                             ldnf1sw.  */
6541                                                          return 1653;
6542                                                        }
6543                                                    }
6544                                                  else
6545                                                    {
6546                                                      if (((word >> 23) & 0x1) == 0)
6547                                                        {
6548                                                          /* 33222222222211111111110000000000
6549                                                             10987654321098765432109876543210
6550                                                             xxxxxxxxxxxxx101xxxx10100x100101
6551                                                             ldnf1b.  */
6552                                                          return 1642;
6553                                                        }
6554                                                      else
6555                                                        {
6556                                                          /* 33222222222211111111110000000000
6557                                                             10987654321098765432109876543210
6558                                                             xxxxxxxxxxxxx101xxxx10110x100101
6559                                                             ldnf1h.  */
6560                                                          return 1646;
6561                                                        }
6562                                                    }
6563                                                }
6564                                            }
6565                                        }
6566                                      else
6567                                        {
6568                                          if (((word >> 22) & 0x1) == 0)
6569                                            {
6570                                              if (((word >> 23) & 0x1) == 0)
6571                                                {
6572                                                  /* 33222222222211111111110000000000
6573                                                     10987654321098765432109876543210
6574                                                     xxxxxxxxxxxxx101xxxxx0000x10011x
6575                                                     st1b.  */
6576                                                  return 1805;
6577                                                }
6578                                              else
6579                                                {
6580                                                  /* 33222222222211111111110000000000
6581                                                     10987654321098765432109876543210
6582                                                     xxxxxxxxxxxxx101xxxxx0010x10011x
6583                                                     st1h.  */
6584                                                  return 1824;
6585                                                }
6586                                            }
6587                                          else
6588                                            {
6589                                              if (((word >> 23) & 0x1) == 0)
6590                                                {
6591                                                  /* 33222222222211111111110000000000
6592                                                     10987654321098765432109876543210
6593                                                     xxxxxxxxxxxxx101xxxxx0100x10011x
6594                                                     st1b.  */
6595                                                  return 1812;
6596                                                }
6597                                              else
6598                                                {
6599                                                  /* 33222222222211111111110000000000
6600                                                     10987654321098765432109876543210
6601                                                     xxxxxxxxxxxxx101xxxxx0110x10011x
6602                                                     st1h.  */
6603                                                  return 1833;
6604                                                }
6605                                            }
6606                                        }
6607                                    }
6608                                  else
6609                                    {
6610                                      if (((word >> 30) & 0x1) == 0)
6611                                        {
6612                                          if (((word >> 31) & 0x1) == 0)
6613                                            {
6614                                              if (((word >> 4) & 0x1) == 0)
6615                                                {
6616                                                  /* 33222222222211111111110000000000
6617                                                     10987654321098765432109876543210
6618                                                     xxxx0xxxxxxxx111xxxxx0xx0x100100
6619                                                     cmplo.  */
6620                                                  return 1290;
6621                                                }
6622                                              else
6623                                                {
6624                                                  /* 33222222222211111111110000000000
6625                                                     10987654321098765432109876543210
6626                                                     xxxx1xxxxxxxx111xxxxx0xx0x100100
6627                                                     cmpls.  */
6628                                                  return 1292;
6629                                                }
6630                                            }
6631                                          else
6632                                            {
6633                                              if (((word >> 22) & 0x1) == 0)
6634                                                {
6635                                                  if (((word >> 23) & 0x1) == 0)
6636                                                    {
6637                                                      /* 33222222222211111111110000000000
6638                                                         10987654321098765432109876543210
6639                                                         xxxxxxxxxxxxx111xxxxx0000x100101
6640                                                         ldnt1b.  */
6641                                                      return 1657;
6642                                                    }
6643                                                  else
6644                                                    {
6645                                                      /* 33222222222211111111110000000000
6646                                                         10987654321098765432109876543210
6647                                                         xxxxxxxxxxxxx111xxxxx0010x100101
6648                                                         ldnt1h.  */
6649                                                      return 1661;
6650                                                    }
6651                                                }
6652                                              else
6653                                                {
6654                                                  if (((word >> 23) & 0x1) == 0)
6655                                                    {
6656                                                      /* 33222222222211111111110000000000
6657                                                         10987654321098765432109876543210
6658                                                         xxxxxxxxxxxxx111xxxxx0100x100101
6659                                                         ld3b.  */
6660                                                      return 1565;
6661                                                    }
6662                                                  else
6663                                                    {
6664                                                      /* 33222222222211111111110000000000
6665                                                         10987654321098765432109876543210
6666                                                         xxxxxxxxxxxxx111xxxxx0110x100101
6667                                                         ld3h.  */
6668                                                      return 1569;
6669                                                    }
6670                                                }
6671                                            }
6672                                        }
6673                                      else
6674                                        {
6675                                          if (((word >> 20) & 0x1) == 0)
6676                                            {
6677                                              if (((word >> 22) & 0x1) == 0)
6678                                                {
6679                                                  /* 33222222222211111111110000000000
6680                                                     10987654321098765432109876543210
6681                                                     xxxxxxxxxxxxx111xxxx000x0x10011x
6682                                                     st1b.  */
6683                                                  return 1810;
6684                                                }
6685                                              else
6686                                                {
6687                                                  if (((word >> 23) & 0x1) == 0)
6688                                                    {
6689                                                      /* 33222222222211111111110000000000
6690                                                         10987654321098765432109876543210
6691                                                         xxxxxxxxxxxxx111xxxx00100x10011x
6692                                                         st1b.  */
6693                                                      return 1813;
6694                                                    }
6695                                                  else
6696                                                    {
6697                                                      /* 33222222222211111111110000000000
6698                                                         10987654321098765432109876543210
6699                                                         xxxxxxxxxxxxx111xxxx00110x10011x
6700                                                         st1h.  */
6701                                                      return 1834;
6702                                                    }
6703                                                }
6704                                            }
6705                                          else
6706                                            {
6707                                              if (((word >> 22) & 0x1) == 0)
6708                                                {
6709                                                  if (((word >> 23) & 0x1) == 0)
6710                                                    {
6711                                                      /* 33222222222211111111110000000000
6712                                                         10987654321098765432109876543210
6713                                                         xxxxxxxxxxxxx111xxxx10000x10011x
6714                                                         stnt1b.  */
6715                                                      return 1874;
6716                                                    }
6717                                                  else
6718                                                    {
6719                                                      /* 33222222222211111111110000000000
6720                                                         10987654321098765432109876543210
6721                                                         xxxxxxxxxxxxx111xxxx10010x10011x
6722                                                         stnt1h.  */
6723                                                      return 1878;
6724                                                    }
6725                                                }
6726                                              else
6727                                                {
6728                                                  if (((word >> 23) & 0x1) == 0)
6729                                                    {
6730                                                      /* 33222222222211111111110000000000
6731                                                         10987654321098765432109876543210
6732                                                         xxxxxxxxxxxxx111xxxx10100x10011x
6733                                                         st3b.  */
6734                                                      return 1858;
6735                                                    }
6736                                                  else
6737                                                    {
6738                                                      /* 33222222222211111111110000000000
6739                                                         10987654321098765432109876543210
6740                                                         xxxxxxxxxxxxx111xxxx10110x10011x
6741                                                         st3h.  */
6742                                                      return 1862;
6743                                                    }
6744                                                }
6745                                            }
6746                                        }
6747                                    }
6748                                }
6749                            }
6750                        }
6751                      else
6752                        {
6753                          if (((word >> 13) & 0x1) == 0)
6754                            {
6755                              if (((word >> 30) & 0x1) == 0)
6756                                {
6757                                  if (((word >> 31) & 0x1) == 0)
6758                                    {
6759                                      if (((word >> 4) & 0x1) == 0)
6760                                        {
6761                                          /* 33222222222211111111110000000000
6762                                             10987654321098765432109876543210
6763                                             xxxx0xxxxxxxx0xxxxxxx1xx0x100100
6764                                             cmphs.  */
6765                                          return 1287;
6766                                        }
6767                                      else
6768                                        {
6769                                          /* 33222222222211111111110000000000
6770                                             10987654321098765432109876543210
6771                                             xxxx1xxxxxxxx0xxxxxxx1xx0x100100
6772                                             cmphi.  */
6773                                          return 1284;
6774                                        }
6775                                    }
6776                                  else
6777                                    {
6778                                      if (((word >> 15) & 0x1) == 0)
6779                                        {
6780                                          if (((word >> 22) & 0x1) == 0)
6781                                            {
6782                                              if (((word >> 23) & 0x1) == 0)
6783                                                {
6784                                                  /* 33222222222211111111110000000000
6785                                                     10987654321098765432109876543210
6786                                                     xxxxxxxxxxxxx0x0xxxxx1000x100101
6787                                                     ld1b.  */
6788                                                  return 1458;
6789                                                }
6790                                              else
6791                                                {
6792                                                  /* 33222222222211111111110000000000
6793                                                     10987654321098765432109876543210
6794                                                     xxxxxxxxxxxxx0x0xxxxx1010x100101
6795                                                     ld1h.  */
6796                                                  return 1478;
6797                                                }
6798                                            }
6799                                          else
6800                                            {
6801                                              if (((word >> 23) & 0x1) == 0)
6802                                                {
6803                                                  /* 33222222222211111111110000000000
6804                                                     10987654321098765432109876543210
6805                                                     xxxxxxxxxxxxx0x0xxxxx1100x100101
6806                                                     ld1b.  */
6807                                                  return 1460;
6808                                                }
6809                                              else
6810                                                {
6811                                                  /* 33222222222211111111110000000000
6812                                                     10987654321098765432109876543210
6813                                                     xxxxxxxxxxxxx0x0xxxxx1110x100101
6814                                                     ld1h.  */
6815                                                  return 1480;
6816                                                }
6817                                            }
6818                                        }
6819                                      else
6820                                        {
6821                                          if (((word >> 22) & 0x1) == 0)
6822                                            {
6823                                              if (((word >> 23) & 0x1) == 0)
6824                                                {
6825                                                  /* 33222222222211111111110000000000
6826                                                     10987654321098765432109876543210
6827                                                     xxxxxxxxxxxxx0x1xxxxx1000x100101
6828                                                     ld2b.  */
6829                                                  return 1556;
6830                                                }
6831                                              else
6832                                                {
6833                                                  /* 33222222222211111111110000000000
6834                                                     10987654321098765432109876543210
6835                                                     xxxxxxxxxxxxx0x1xxxxx1010x100101
6836                                                     ld2h.  */
6837                                                  return 1560;
6838                                                }
6839                                            }
6840                                          else
6841                                            {
6842                                              if (((word >> 23) & 0x1) == 0)
6843                                                {
6844                                                  /* 33222222222211111111110000000000
6845                                                     10987654321098765432109876543210
6846                                                     xxxxxxxxxxxxx0x1xxxxx1100x100101
6847                                                     ld4b.  */
6848                                                  return 1572;
6849                                                }
6850                                              else
6851                                                {
6852                                                  /* 33222222222211111111110000000000
6853                                                     10987654321098765432109876543210
6854                                                     xxxxxxxxxxxxx0x1xxxxx1110x100101
6855                                                     ld4h.  */
6856                                                  return 1576;
6857                                                }
6858                                            }
6859                                        }
6860                                    }
6861                                }
6862                              else
6863                                {
6864                                  if (((word >> 15) & 0x1) == 0)
6865                                    {
6866                                      if (((word >> 14) & 0x1) == 0)
6867                                        {
6868                                          if (((word >> 12) & 0x1) == 0)
6869                                            {
6870                                              if (((word >> 10) & 0x1) == 0)
6871                                                {
6872                                                  if (((word >> 23) & 0x1) == 0)
6873                                                    {
6874                                                      /* 33222222222211111111110000000000
6875                                                         10987654321098765432109876543210
6876                                                         xxxxxxxxxx0x0000xxxxx1x00x10011x
6877                                                         fmla.  */
6878                                                      return 1395;
6879                                                    }
6880                                                  else
6881                                                    {
6882                                                      if (((word >> 22) & 0x1) == 0)
6883                                                        {
6884                                                          /* 33222222222211111111110000000000
6885                                                             10987654321098765432109876543210
6886                                                             xxxxxxxxxx0x0000xxxxx1010x10011x
6887                                                             fmla.  */
6888                                                          return 1396;
6889                                                        }
6890                                                      else
6891                                                        {
6892                                                          /* 33222222222211111111110000000000
6893                                                             10987654321098765432109876543210
6894                                                             xxxxxxxxxx0x0000xxxxx1110x10011x
6895                                                             fmla.  */
6896                                                          return 1397;
6897                                                        }
6898                                                    }
6899                                                }
6900                                              else
6901                                                {
6902                                                  if (((word >> 23) & 0x1) == 0)
6903                                                    {
6904                                                      /* 33222222222211111111110000000000
6905                                                         10987654321098765432109876543210
6906                                                         xxxxxxxxxx1x0000xxxxx1x00x10011x
6907                                                         fmls.  */
6908                                                      return 1399;
6909                                                    }
6910                                                  else
6911                                                    {
6912                                                      if (((word >> 22) & 0x1) == 0)
6913                                                        {
6914                                                          /* 33222222222211111111110000000000
6915                                                             10987654321098765432109876543210
6916                                                             xxxxxxxxxx1x0000xxxxx1010x10011x
6917                                                             fmls.  */
6918                                                          return 1400;
6919                                                        }
6920                                                      else
6921                                                        {
6922                                                          /* 33222222222211111111110000000000
6923                                                             10987654321098765432109876543210
6924                                                             xxxxxxxxxx1x0000xxxxx1110x10011x
6925                                                             fmls.  */
6926                                                          return 1401;
6927                                                        }
6928                                                    }
6929                                                }
6930                                            }
6931                                          else
6932                                            {
6933                                              if (((word >> 22) & 0x1) == 0)
6934                                                {
6935                                                  /* 33222222222211111111110000000000
6936                                                     10987654321098765432109876543210
6937                                                     xxxxxxxxxxxx1000xxxxx10x0x10011x
6938                                                     fcmla.  */
6939                                                  return 1343;
6940                                                }
6941                                              else
6942                                                {
6943                                                  /* 33222222222211111111110000000000
6944                                                     10987654321098765432109876543210
6945                                                     xxxxxxxxxxxx1000xxxxx11x0x10011x
6946                                                     fcmla.  */
6947                                                  return 1344;
6948                                                }
6949                                            }
6950                                        }
6951                                      else
6952                                        {
6953                                          if (((word >> 22) & 0x1) == 0)
6954                                            {
6955                                              if (((word >> 23) & 0x1) == 0)
6956                                                {
6957                                                  /* 33222222222211111111110000000000
6958                                                     10987654321098765432109876543210
6959                                                     xxxxxxxxxxxxx010xxxxx1000x10011x
6960                                                     st1b.  */
6961                                                  return 1806;
6962                                                }
6963                                              else
6964                                                {
6965                                                  /* 33222222222211111111110000000000
6966                                                     10987654321098765432109876543210
6967                                                     xxxxxxxxxxxxx010xxxxx1010x10011x
6968                                                     st1h.  */
6969                                                  return 1825;
6970                                                }
6971                                            }
6972                                          else
6973                                            {
6974                                              if (((word >> 23) & 0x1) == 0)
6975                                                {
6976                                                  /* 33222222222211111111110000000000
6977                                                     10987654321098765432109876543210
6978                                                     xxxxxxxxxxxxx010xxxxx1100x10011x
6979                                                     st1b.  */
6980                                                  return 1809;
6981                                                }
6982                                              else
6983                                                {
6984                                                  /* 33222222222211111111110000000000
6985                                                     10987654321098765432109876543210
6986                                                     xxxxxxxxxxxxx010xxxxx1110x10011x
6987                                                     st1h.  */
6988                                                  return 1830;
6989                                                }
6990                                            }
6991                                        }
6992                                    }
6993                                  else
6994                                    {
6995                                      if (((word >> 22) & 0x1) == 0)
6996                                        {
6997                                          /* 33222222222211111111110000000000
6998                                             10987654321098765432109876543210
6999                                             xxxxxxxxxxxxx0x1xxxxx10x0x10011x
7000                                             st1h.  */
7001                                          return 1826;
7002                                        }
7003                                      else
7004                                        {
7005                                          /* 33222222222211111111110000000000
7006                                             10987654321098765432109876543210
7007                                             xxxxxxxxxxxxx0x1xxxxx11x0x10011x
7008                                             st1h.  */
7009                                          return 1831;
7010                                        }
7011                                    }
7012                                }
7013                            }
7014                          else
7015                            {
7016                              if (((word >> 30) & 0x1) == 0)
7017                                {
7018                                  if (((word >> 31) & 0x1) == 0)
7019                                    {
7020                                      if (((word >> 4) & 0x1) == 0)
7021                                        {
7022                                          /* 33222222222211111111110000000000
7023                                             10987654321098765432109876543210
7024                                             xxxx0xxxxxxxx1xxxxxxx1xx0x100100
7025                                             cmplo.  */
7026                                          return 1291;
7027                                        }
7028                                      else
7029                                        {
7030                                          /* 33222222222211111111110000000000
7031                                             10987654321098765432109876543210
7032                                             xxxx1xxxxxxxx1xxxxxxx1xx0x100100
7033                                             cmpls.  */
7034                                          return 1293;
7035                                        }
7036                                    }
7037                                  else
7038                                    {
7039                                      if (((word >> 14) & 0x1) == 0)
7040                                        {
7041                                          if (((word >> 20) & 0x1) == 0)
7042                                            {
7043                                              if (((word >> 22) & 0x1) == 0)
7044                                                {
7045                                                  if (((word >> 23) & 0x1) == 0)
7046                                                    {
7047                                                      /* 33222222222211111111110000000000
7048                                                         10987654321098765432109876543210
7049                                                         xxxxxxxxxxxxx10xxxxx01000x100101
7050                                                         ld1b.  */
7051                                                      return 1465;
7052                                                    }
7053                                                  else
7054                                                    {
7055                                                      /* 33222222222211111111110000000000
7056                                                         10987654321098765432109876543210
7057                                                         xxxxxxxxxxxxx10xxxxx01010x100101
7058                                                         ld1h.  */
7059                                                      return 1486;
7060                                                    }
7061                                                }
7062                                              else
7063                                                {
7064                                                  if (((word >> 23) & 0x1) == 0)
7065                                                    {
7066                                                      /* 33222222222211111111110000000000
7067                                                         10987654321098765432109876543210
7068                                                         xxxxxxxxxxxxx10xxxxx01100x100101
7069                                                         ld1b.  */
7070                                                      return 1467;
7071                                                    }
7072                                                  else
7073                                                    {
7074                                                      /* 33222222222211111111110000000000
7075                                                         10987654321098765432109876543210
7076                                                         xxxxxxxxxxxxx10xxxxx01110x100101
7077                                                         ld1h.  */
7078                                                      return 1488;
7079                                                    }
7080                                                }
7081                                            }
7082                                          else
7083                                            {
7084                                              if (((word >> 22) & 0x1) == 0)
7085                                                {
7086                                                  if (((word >> 23) & 0x1) == 0)
7087                                                    {
7088                                                      /* 33222222222211111111110000000000
7089                                                         10987654321098765432109876543210
7090                                                         xxxxxxxxxxxxx10xxxxx11000x100101
7091                                                         ldnf1b.  */
7092                                                      return 1641;
7093                                                    }
7094                                                  else
7095                                                    {
7096                                                      /* 33222222222211111111110000000000
7097                                                         10987654321098765432109876543210
7098                                                         xxxxxxxxxxxxx10xxxxx11010x100101
7099                                                         ldnf1h.  */
7100                                                      return 1645;
7101                                                    }
7102                                                }
7103                                              else
7104                                                {
7105                                                  if (((word >> 23) & 0x1) == 0)
7106                                                    {
7107                                                      /* 33222222222211111111110000000000
7108                                                         10987654321098765432109876543210
7109                                                         xxxxxxxxxxxxx10xxxxx11100x100101
7110                                                         ldnf1b.  */
7111                                                      return 1643;
7112                                                    }
7113                                                  else
7114                                                    {
7115                                                      /* 33222222222211111111110000000000
7116                                                         10987654321098765432109876543210
7117                                                         xxxxxxxxxxxxx10xxxxx11110x100101
7118                                                         ldnf1h.  */
7119                                                      return 1647;
7120                                                    }
7121                                                }
7122                                            }
7123                                        }
7124                                      else
7125                                        {
7126                                          if (((word >> 15) & 0x1) == 0)
7127                                            {
7128                                              if (((word >> 22) & 0x1) == 0)
7129                                                {
7130                                                  if (((word >> 23) & 0x1) == 0)
7131                                                    {
7132                                                      /* 33222222222211111111110000000000
7133                                                         10987654321098765432109876543210
7134                                                         xxxxxxxxxxxxx110xxxxx1000x100101
7135                                                         ldff1b.  */
7136                                                      return 1582;
7137                                                    }
7138                                                  else
7139                                                    {
7140                                                      /* 33222222222211111111110000000000
7141                                                         10987654321098765432109876543210
7142                                                         xxxxxxxxxxxxx110xxxxx1010x100101
7143                                                         ldff1h.  */
7144                                                      return 1597;
7145                                                    }
7146                                                }
7147                                              else
7148                                                {
7149                                                  if (((word >> 23) & 0x1) == 0)
7150                                                    {
7151                                                      /* 33222222222211111111110000000000
7152                                                         10987654321098765432109876543210
7153                                                         xxxxxxxxxxxxx110xxxxx1100x100101
7154                                                         ldff1b.  */
7155                                                      return 1584;
7156                                                    }
7157                                                  else
7158                                                    {
7159                                                      /* 33222222222211111111110000000000
7160                                                         10987654321098765432109876543210
7161                                                         xxxxxxxxxxxxx110xxxxx1110x100101
7162                                                         ldff1h.  */
7163                                                      return 1599;
7164                                                    }
7165                                                }
7166                                            }
7167                                          else
7168                                            {
7169                                              if (((word >> 22) & 0x1) == 0)
7170                                                {
7171                                                  if (((word >> 23) & 0x1) == 0)
7172                                                    {
7173                                                      /* 33222222222211111111110000000000
7174                                                         10987654321098765432109876543210
7175                                                         xxxxxxxxxxxxx111xxxxx1000x100101
7176                                                         ld2b.  */
7177                                                      return 1557;
7178                                                    }
7179                                                  else
7180                                                    {
7181                                                      /* 33222222222211111111110000000000
7182                                                         10987654321098765432109876543210
7183                                                         xxxxxxxxxxxxx111xxxxx1010x100101
7184                                                         ld2h.  */
7185                                                      return 1561;
7186                                                    }
7187                                                }
7188                                              else
7189                                                {
7190                                                  if (((word >> 23) & 0x1) == 0)
7191                                                    {
7192                                                      /* 33222222222211111111110000000000
7193                                                         10987654321098765432109876543210
7194                                                         xxxxxxxxxxxxx111xxxxx1100x100101
7195                                                         ld4b.  */
7196                                                      return 1573;
7197                                                    }
7198                                                  else
7199                                                    {
7200                                                      /* 33222222222211111111110000000000
7201                                                         10987654321098765432109876543210
7202                                                         xxxxxxxxxxxxx111xxxxx1110x100101
7203                                                         ld4h.  */
7204                                                      return 1577;
7205                                                    }
7206                                                }
7207                                            }
7208                                        }
7209                                    }
7210                                }
7211                              else
7212                                {
7213                                  if (((word >> 14) & 0x1) == 0)
7214                                    {
7215                                      if (((word >> 15) & 0x1) == 0)
7216                                        {
7217                                          if (((word >> 23) & 0x1) == 0)
7218                                            {
7219                                              /* 33222222222211111111110000000000
7220                                                 10987654321098765432109876543210
7221                                                 xxxxxxxxxxxxx100xxxxx1x00x10011x
7222                                                 fmul.  */
7223                                              return 1406;
7224                                            }
7225                                          else
7226                                            {
7227                                              if (((word >> 22) & 0x1) == 0)
7228                                                {
7229                                                  /* 33222222222211111111110000000000
7230                                                     10987654321098765432109876543210
7231                                                     xxxxxxxxxxxxx100xxxxx1010x10011x
7232                                                     fmul.  */
7233                                                  return 1407;
7234                                                }
7235                                              else
7236                                                {
7237                                                  /* 33222222222211111111110000000000
7238                                                     10987654321098765432109876543210
7239                                                     xxxxxxxxxxxxx100xxxxx1110x10011x
7240                                                     fmul.  */
7241                                                  return 1408;
7242                                                }
7243                                            }
7244                                        }
7245                                      else
7246                                        {
7247                                          if (((word >> 22) & 0x1) == 0)
7248                                            {
7249                                              /* 33222222222211111111110000000000
7250                                                 10987654321098765432109876543210
7251                                                 xxxxxxxxxxxxx101xxxxx10x0x10011x
7252                                                 st1h.  */
7253                                              return 1827;
7254                                            }
7255                                          else
7256                                            {
7257                                              if (((word >> 23) & 0x1) == 0)
7258                                                {
7259                                                  /* 33222222222211111111110000000000
7260                                                     10987654321098765432109876543210
7261                                                     xxxxxxxxxxxxx101xxxxx1100x10011x
7262                                                     st1b.  */
7263                                                  return 1814;
7264                                                }
7265                                              else
7266                                                {
7267                                                  /* 33222222222211111111110000000000
7268                                                     10987654321098765432109876543210
7269                                                     xxxxxxxxxxxxx101xxxxx1110x10011x
7270                                                     st1h.  */
7271                                                  return 1835;
7272                                                }
7273                                            }
7274                                        }
7275                                    }
7276                                  else
7277                                    {
7278                                      if (((word >> 15) & 0x1) == 0)
7279                                        {
7280                                          if (((word >> 22) & 0x1) == 0)
7281                                            {
7282                                              if (((word >> 23) & 0x1) == 0)
7283                                                {
7284                                                  /* 33222222222211111111110000000000
7285                                                     10987654321098765432109876543210
7286                                                     xxxxxxxxxxxxx110xxxxx1000x10011x
7287                                                     st2b.  */
7288                                                  return 1849;
7289                                                }
7290                                              else
7291                                                {
7292                                                  /* 33222222222211111111110000000000
7293                                                     10987654321098765432109876543210
7294                                                     xxxxxxxxxxxxx110xxxxx1010x10011x
7295                                                     st2h.  */
7296                                                  return 1853;
7297                                                }
7298                                            }
7299                                          else
7300                                            {
7301                                              if (((word >> 23) & 0x1) == 0)
7302                                                {
7303                                                  /* 33222222222211111111110000000000
7304                                                     10987654321098765432109876543210
7305                                                     xxxxxxxxxxxxx110xxxxx1100x10011x
7306                                                     st4b.  */
7307                                                  return 1865;
7308                                                }
7309                                              else
7310                                                {
7311                                                  /* 33222222222211111111110000000000
7312                                                     10987654321098765432109876543210
7313                                                     xxxxxxxxxxxxx110xxxxx1110x10011x
7314                                                     st4h.  */
7315                                                  return 1869;
7316                                                }
7317                                            }
7318                                        }
7319                                      else
7320                                        {
7321                                          if (((word >> 20) & 0x1) == 0)
7322                                            {
7323                                              if (((word >> 22) & 0x1) == 0)
7324                                                {
7325                                                  if (((word >> 23) & 0x1) == 0)
7326                                                    {
7327                                                      /* 33222222222211111111110000000000
7328                                                         10987654321098765432109876543210
7329                                                         xxxxxxxxxxxxx111xxxx01000x10011x
7330                                                         st1b.  */
7331                                                      return 1811;
7332                                                    }
7333                                                  else
7334                                                    {
7335                                                      /* 33222222222211111111110000000000
7336                                                         10987654321098765432109876543210
7337                                                         xxxxxxxxxxxxx111xxxx01010x10011x
7338                                                         st1h.  */
7339                                                      return 1832;
7340                                                    }
7341                                                }
7342                                              else
7343                                                {
7344                                                  if (((word >> 23) & 0x1) == 0)
7345                                                    {
7346                                                      /* 33222222222211111111110000000000
7347                                                         10987654321098765432109876543210
7348                                                         xxxxxxxxxxxxx111xxxx01100x10011x
7349                                                         st1b.  */
7350                                                      return 1815;
7351                                                    }
7352                                                  else
7353                                                    {
7354                                                      /* 33222222222211111111110000000000
7355                                                         10987654321098765432109876543210
7356                                                         xxxxxxxxxxxxx111xxxx01110x10011x
7357                                                         st1h.  */
7358                                                      return 1836;
7359                                                    }
7360                                                }
7361                                            }
7362                                          else
7363                                            {
7364                                              if (((word >> 22) & 0x1) == 0)
7365                                                {
7366                                                  if (((word >> 23) & 0x1) == 0)
7367                                                    {
7368                                                      /* 33222222222211111111110000000000
7369                                                         10987654321098765432109876543210
7370                                                         xxxxxxxxxxxxx111xxxx11000x10011x
7371                                                         st2b.  */
7372                                                      return 1850;
7373                                                    }
7374                                                  else
7375                                                    {
7376                                                      /* 33222222222211111111110000000000
7377                                                         10987654321098765432109876543210
7378                                                         xxxxxxxxxxxxx111xxxx11010x10011x
7379                                                         st2h.  */
7380                                                      return 1854;
7381                                                    }
7382                                                }
7383                                              else
7384                                                {
7385                                                  if (((word >> 23) & 0x1) == 0)
7386                                                    {
7387                                                      /* 33222222222211111111110000000000
7388                                                         10987654321098765432109876543210
7389                                                         xxxxxxxxxxxxx111xxxx11100x10011x
7390                                                         st4b.  */
7391                                                      return 1866;
7392                                                    }
7393                                                  else
7394                                                    {
7395                                                      /* 33222222222211111111110000000000
7396                                                         10987654321098765432109876543210
7397                                                         xxxxxxxxxxxxx111xxxx11110x10011x
7398                                                         st4h.  */
7399                                                      return 1870;
7400                                                    }
7401                                                }
7402                                            }
7403                                        }
7404                                    }
7405                                }
7406                            }
7407                        }
7408                    }
7409                }
7410              else
7411                {
7412                  if (((word >> 29) & 0x1) == 0)
7413                    {
7414                      if (((word >> 30) & 0x1) == 0)
7415                        {
7416                          if (((word >> 31) & 0x1) == 0)
7417                            {
7418                              if (((word >> 21) & 0x1) == 0)
7419                                {
7420                                  if (((word >> 20) & 0x1) == 0)
7421                                    {
7422                                      if (((word >> 22) & 0x1) == 0)
7423                                        {
7424                                          if (((word >> 23) & 0x1) == 0)
7425                                            {
7426                                              /* 33222222222211111111110000000000
7427                                                 10987654321098765432109876543210
7428                                                 xxxxxxxxxxxxxxxxxxxx00001x100000
7429                                                 orr.  */
7430                                              return 1695;
7431                                            }
7432                                          else
7433                                            {
7434                                              /* 33222222222211111111110000000000
7435                                                 10987654321098765432109876543210
7436                                                 xxxxxxxxxxxxxxxxxxxx00011x100000
7437                                                 and.  */
7438                                              return 1239;
7439                                            }
7440                                        }
7441                                      else
7442                                        {
7443                                          if (((word >> 23) & 0x1) == 0)
7444                                            {
7445                                              /* 33222222222211111111110000000000
7446                                                 10987654321098765432109876543210
7447                                                 xxxxxxxxxxxxxxxxxxxx00101x100000
7448                                                 eor.  */
7449                                              return 1326;
7450                                            }
7451                                          else
7452                                            {
7453                                              /* 33222222222211111111110000000000
7454                                                 10987654321098765432109876543210
7455                                                 xxxxxxxxxxxxxxxxxxxx00111x100000
7456                                                 dupm.  */
7457                                              return 1324;
7458                                            }
7459                                        }
7460                                    }
7461                                  else
7462                                    {
7463                                      if (((word >> 15) & 0x1) == 0)
7464                                        {
7465                                          /* 33222222222211111111110000000000
7466                                             10987654321098765432109876543210
7467                                             xxxxxxxxxxxxxxx0xxxx10xx1x100000
7468                                             cpy.  */
7469                                          return 1309;
7470                                        }
7471                                      else
7472                                        {
7473                                          /* 33222222222211111111110000000000
7474                                             10987654321098765432109876543210
7475                                             xxxxxxxxxxxxxxx1xxxx10xx1x100000
7476                                             fcpy.  */
7477                                          return 1356;
7478                                        }
7479                                    }
7480                                }
7481                              else
7482                                {
7483                                  if (((word >> 14) & 0x1) == 0)
7484                                    {
7485                                      if (((word >> 13) & 0x1) == 0)
7486                                        {
7487                                          if (((word >> 15) & 0x1) == 0)
7488                                            {
7489                                              /* 33222222222211111111110000000000
7490                                                 10987654321098765432109876543210
7491                                                 xxxxxxxxxxxxx000xxxxx1xx1x100000
7492                                                 ext.  */
7493                                              return 1331;
7494                                            }
7495                                          else
7496                                            {
7497                                              if (((word >> 16) & 0x1) == 0)
7498                                                {
7499                                                  if (((word >> 17) & 0x1) == 0)
7500                                                    {
7501                                                      if (((word >> 18) & 0x1) == 0)
7502                                                        {
7503                                                          if (((word >> 19) & 0x1) == 0)
7504                                                            {
7505                                                              /* 33222222222211111111110000000000
7506                                                                 10987654321098765432109876543210
7507                                                                 xxxxxxxxxxxxx0010000x1xx1x100000
7508                                                                 cpy.  */
7509                                                              return 1307;
7510                                                            }
7511                                                          else
7512                                                            {
7513                                                              /* 33222222222211111111110000000000
7514                                                                 10987654321098765432109876543210
7515                                                                 xxxxxxxxxxxxx0010001x1xx1x100000
7516                                                                 clasta.  */
7517                                                              return 1265;
7518                                                            }
7519                                                        }
7520                                                      else
7521                                                        {
7522                                                          if (((word >> 19) & 0x1) == 0)
7523                                                            {
7524                                                              /* 33222222222211111111110000000000
7525                                                                 10987654321098765432109876543210
7526                                                                 xxxxxxxxxxxxx0010010x1xx1x100000
7527                                                                 revb.  */
7528                                                              return 1743;
7529                                                            }
7530                                                          else
7531                                                            {
7532                                                              /* 33222222222211111111110000000000
7533                                                                 10987654321098765432109876543210
7534                                                                 xxxxxxxxxxxxx0010011x1xx1x100000
7535                                                                 splice.  */
7536                                                              return 1770;
7537                                                            }
7538                                                        }
7539                                                    }
7540                                                  else
7541                                                    {
7542                                                      if (((word >> 18) & 0x1) == 0)
7543                                                        {
7544                                                          if (((word >> 19) & 0x1) == 0)
7545                                                            {
7546                                                              /* 33222222222211111111110000000000
7547                                                                 10987654321098765432109876543210
7548                                                                 xxxxxxxxxxxxx0010100x1xx1x100000
7549                                                                 lasta.  */
7550                                                              return 1453;
7551                                                            }
7552                                                          else
7553                                                            {
7554                                                              /* 33222222222211111111110000000000
7555                                                                 10987654321098765432109876543210
7556                                                                 xxxxxxxxxxxxx0010101x1xx1x100000
7557                                                                 clasta.  */
7558                                                              return 1266;
7559                                                            }
7560                                                        }
7561                                                      else
7562                                                        {
7563                                                          /* 33222222222211111111110000000000
7564                                                             10987654321098765432109876543210
7565                                                             xxxxxxxxxxxxx001011xx1xx1x100000
7566                                                             revw.  */
7567                                                          return 1745;
7568                                                        }
7569                                                    }
7570                                                }
7571                                              else
7572                                                {
7573                                                  if (((word >> 17) & 0x1) == 0)
7574                                                    {
7575                                                      if (((word >> 18) & 0x1) == 0)
7576                                                        {
7577                                                          if (((word >> 19) & 0x1) == 0)
7578                                                            {
7579                                                              /* 33222222222211111111110000000000
7580                                                                 10987654321098765432109876543210
7581                                                                 xxxxxxxxxxxxx0011000x1xx1x100000
7582                                                                 compact.  */
7583                                                              return 1306;
7584                                                            }
7585                                                          else
7586                                                            {
7587                                                              /* 33222222222211111111110000000000
7588                                                                 10987654321098765432109876543210
7589                                                                 xxxxxxxxxxxxx0011001x1xx1x100000
7590                                                                 clastb.  */
7591                                                              return 1268;
7592                                                            }
7593                                                        }
7594                                                      else
7595                                                        {
7596                                                          /* 33222222222211111111110000000000
7597                                                             10987654321098765432109876543210
7598                                                             xxxxxxxxxxxxx001101xx1xx1x100000
7599                                                             revh.  */
7600                                                          return 1744;
7601                                                        }
7602                                                    }
7603                                                  else
7604                                                    {
7605                                                      if (((word >> 18) & 0x1) == 0)
7606                                                        {
7607                                                          if (((word >> 19) & 0x1) == 0)
7608                                                            {
7609                                                              /* 33222222222211111111110000000000
7610                                                                 10987654321098765432109876543210
7611                                                                 xxxxxxxxxxxxx0011100x1xx1x100000
7612                                                                 lastb.  */
7613                                                              return 1455;
7614                                                            }
7615                                                          else
7616                                                            {
7617                                                              /* 33222222222211111111110000000000
7618                                                                 10987654321098765432109876543210
7619                                                                 xxxxxxxxxxxxx0011101x1xx1x100000
7620                                                                 clastb.  */
7621                                                              return 1269;
7622                                                            }
7623                                                        }
7624                                                      else
7625                                                        {
7626                                                          /* 33222222222211111111110000000000
7627                                                             10987654321098765432109876543210
7628                                                             xxxxxxxxxxxxx001111xx1xx1x100000
7629                                                             rbit.  */
7630                                                          return 1736;
7631                                                        }
7632                                                    }
7633                                                }
7634                                            }
7635                                        }
7636                                      else
7637                                        {
7638                                          if (((word >> 15) & 0x1) == 0)
7639                                            {
7640                                              if (((word >> 11) & 0x1) == 0)
7641                                                {
7642                                                  if (((word >> 12) & 0x1) == 0)
7643                                                    {
7644                                                      /* 33222222222211111111110000000000
7645                                                         10987654321098765432109876543210
7646                                                         xxxxxxxxxxx00100xxxxx1xx1x100000
7647                                                         dup.  */
7648                                                      return 1322;
7649                                                    }
7650                                                  else
7651                                                    {
7652                                                      /* 33222222222211111111110000000000
7653                                                         10987654321098765432109876543210
7654                                                         xxxxxxxxxxx01100xxxxx1xx1x100000
7655                                                         tbl.  */
7656                                                      return 1893;
7657                                                    }
7658                                                }
7659                                              else
7660                                                {
7661                                                  if (((word >> 16) & 0x1) == 0)
7662                                                    {
7663                                                      if (((word >> 17) & 0x1) == 0)
7664                                                        {
7665                                                          if (((word >> 18) & 0x1) == 0)
7666                                                            {
7667                                                              if (((word >> 19) & 0x1) == 0)
7668                                                                {
7669                                                                  if (((word >> 20) & 0x1) == 0)
7670                                                                    {
7671                                                                      /* 33222222222211111111110000000000
7672                                                                         10987654321098765432109876543210
7673                                                                         xxxxxxxxxxx1x100000001xx1x100000
7674                                                                         dup.  */
7675                                                                      return 1321;
7676                                                                    }
7677                                                                  else
7678                                                                    {
7679                                                                      /* 33222222222211111111110000000000
7680                                                                         10987654321098765432109876543210
7681                                                                         xxxxxxxxxxx1x100000011xx1x100000
7682                                                                         sunpklo.  */
7683                                                                      return 1889;
7684                                                                    }
7685                                                                }
7686                                                              else
7687                                                                {
7688                                                                  /* 33222222222211111111110000000000
7689                                                                     10987654321098765432109876543210
7690                                                                     xxxxxxxxxxx1x1000001x1xx1x100000
7691                                                                     rev.  */
7692                                                                  return 1742;
7693                                                                }
7694                                                            }
7695                                                          else
7696                                                            {
7697                                                              if (((word >> 20) & 0x1) == 0)
7698                                                                {
7699                                                                  /* 33222222222211111111110000000000
7700                                                                     10987654321098765432109876543210
7701                                                                     xxxxxxxxxxx1x100001x01xx1x100000
7702                                                                     insr.  */
7703                                                                  return 1450;
7704                                                                }
7705                                                              else
7706                                                                {
7707                                                                  /* 33222222222211111111110000000000
7708                                                                     10987654321098765432109876543210
7709                                                                     xxxxxxxxxxx1x100001x11xx1x100000
7710                                                                     insr.  */
7711                                                                  return 1451;
7712                                                                }
7713                                                            }
7714                                                        }
7715                                                      else
7716                                                        {
7717                                                          /* 33222222222211111111110000000000
7718                                                             10987654321098765432109876543210
7719                                                             xxxxxxxxxxx1x10001xxx1xx1x100000
7720                                                             uunpklo.  */
7721                                                          return 1952;
7722                                                        }
7723                                                    }
7724                                                  else
7725                                                    {
7726                                                      if (((word >> 17) & 0x1) == 0)
7727                                                        {
7728                                                          /* 33222222222211111111110000000000
7729                                                             10987654321098765432109876543210
7730                                                             xxxxxxxxxxx1x10010xxx1xx1x100000
7731                                                             sunpkhi.  */
7732                                                          return 1888;
7733                                                        }
7734                                                      else
7735                                                        {
7736                                                          /* 33222222222211111111110000000000
7737                                                             10987654321098765432109876543210
7738                                                             xxxxxxxxxxx1x10011xxx1xx1x100000
7739                                                             uunpkhi.  */
7740                                                          return 1951;
7741                                                        }
7742                                                    }
7743                                                }
7744                                            }
7745                                          else
7746                                            {
7747                                              if (((word >> 16) & 0x1) == 0)
7748                                                {
7749                                                  if (((word >> 19) & 0x1) == 0)
7750                                                    {
7751                                                      if (((word >> 20) & 0x1) == 0)
7752                                                        {
7753                                                          /* 33222222222211111111110000000000
7754                                                             10987654321098765432109876543210
7755                                                             xxxxxxxxxxxxx1010xx001xx1x100000
7756                                                             lasta.  */
7757                                                          return 1452;
7758                                                        }
7759                                                      else
7760                                                        {
7761                                                          /* 33222222222211111111110000000000
7762                                                             10987654321098765432109876543210
7763                                                             xxxxxxxxxxxxx1010xx011xx1x100000
7764                                                             clasta.  */
7765                                                          return 1267;
7766                                                        }
7767                                                    }
7768                                                  else
7769                                                    {
7770                                                      /* 33222222222211111111110000000000
7771                                                         10987654321098765432109876543210
7772                                                         xxxxxxxxxxxxx1010xx1x1xx1x100000
7773                                                         cpy.  */
7774                                                      return 1308;
7775                                                    }
7776                                                }
7777                                              else
7778                                                {
7779                                                  if (((word >> 20) & 0x1) == 0)
7780                                                    {
7781                                                      /* 33222222222211111111110000000000
7782                                                         10987654321098765432109876543210
7783                                                         xxxxxxxxxxxxx1011xxx01xx1x100000
7784                                                         lastb.  */
7785                                                      return 1454;
7786                                                    }
7787                                                  else
7788                                                    {
7789                                                      /* 33222222222211111111110000000000
7790                                                         10987654321098765432109876543210
7791                                                         xxxxxxxxxxxxx1011xxx11xx1x100000
7792                                                         clastb.  */
7793                                                      return 1270;
7794                                                    }
7795                                                }
7796                                            }
7797                                        }
7798                                    }
7799                                  else
7800                                    {
7801                                      if (((word >> 15) & 0x1) == 0)
7802                                        {
7803                                          if (((word >> 10) & 0x1) == 0)
7804                                            {
7805                                              if (((word >> 11) & 0x1) == 0)
7806                                                {
7807                                                  if (((word >> 12) & 0x1) == 0)
7808                                                    {
7809                                                      if (((word >> 13) & 0x1) == 0)
7810                                                        {
7811                                                          if (((word >> 20) & 0x1) == 0)
7812                                                            {
7813                                                              /* 33222222222211111111110000000000
7814                                                                 10987654321098765432109876543210
7815                                                                 xxxxxxxxxx000010xxxx01xx1x100000
7816                                                                 zip1.  */
7817                                                              return 1969;
7818                                                            }
7819                                                          else
7820                                                            {
7821                                                              if (((word >> 16) & 0x1) == 0)
7822                                                                {
7823                                                                  if (((word >> 18) & 0x1) == 0)
7824                                                                    {
7825                                                                      /* 33222222222211111111110000000000
7826                                                                         10987654321098765432109876543210
7827                                                                         xxxxxxxxxx0000100x0x11xx1x100000
7828                                                                         punpklo.  */
7829                                                                      return 1735;
7830                                                                    }
7831                                                                  else
7832                                                                    {
7833                                                                      /* 33222222222211111111110000000000
7834                                                                         10987654321098765432109876543210
7835                                                                         xxxxxxxxxx0000100x1x11xx1x100000
7836                                                                         rev.  */
7837                                                                      return 1741;
7838                                                                    }
7839                                                                }
7840                                                              else
7841                                                                {
7842                                                                  /* 33222222222211111111110000000000
7843                                                                     10987654321098765432109876543210
7844                                                                     xxxxxxxxxx0000101xxx11xx1x100000
7845                                                                     punpkhi.  */
7846                                                                  return 1734;
7847                                                                }
7848                                                            }
7849                                                        }
7850                                                      else
7851                                                        {
7852                                                          /* 33222222222211111111110000000000
7853                                                             10987654321098765432109876543210
7854                                                             xxxxxxxxxx000110xxxxx1xx1x100000
7855                                                             zip1.  */
7856                                                          return 1970;
7857                                                        }
7858                                                    }
7859                                                  else
7860                                                    {
7861                                                      if (((word >> 13) & 0x1) == 0)
7862                                                        {
7863                                                          /* 33222222222211111111110000000000
7864                                                             10987654321098765432109876543210
7865                                                             xxxxxxxxxx001010xxxxx1xx1x100000
7866                                                             trn1.  */
7867                                                          return 1894;
7868                                                        }
7869                                                      else
7870                                                        {
7871                                                          /* 33222222222211111111110000000000
7872                                                             10987654321098765432109876543210
7873                                                             xxxxxxxxxx001110xxxxx1xx1x100000
7874                                                             trn1.  */
7875                                                          return 1895;
7876                                                        }
7877                                                    }
7878                                                }
7879                                              else
7880                                                {
7881                                                  if (((word >> 13) & 0x1) == 0)
7882                                                    {
7883                                                      /* 33222222222211111111110000000000
7884                                                         10987654321098765432109876543210
7885                                                         xxxxxxxxxx01x010xxxxx1xx1x100000
7886                                                         uzp1.  */
7887                                                      return 1956;
7888                                                    }
7889                                                  else
7890                                                    {
7891                                                      /* 33222222222211111111110000000000
7892                                                         10987654321098765432109876543210
7893                                                         xxxxxxxxxx01x110xxxxx1xx1x100000
7894                                                         uzp1.  */
7895                                                      return 1957;
7896                                                    }
7897                                                }
7898                                            }
7899                                          else
7900                                            {
7901                                              if (((word >> 11) & 0x1) == 0)
7902                                                {
7903                                                  if (((word >> 12) & 0x1) == 0)
7904                                                    {
7905                                                      if (((word >> 13) & 0x1) == 0)
7906                                                        {
7907                                                          /* 33222222222211111111110000000000
7908                                                             10987654321098765432109876543210
7909                                                             xxxxxxxxxx100010xxxxx1xx1x100000
7910                                                             zip2.  */
7911                                                          return 1971;
7912                                                        }
7913                                                      else
7914                                                        {
7915                                                          /* 33222222222211111111110000000000
7916                                                             10987654321098765432109876543210
7917                                                             xxxxxxxxxx100110xxxxx1xx1x100000
7918                                                             zip2.  */
7919                                                          return 1972;
7920                                                        }
7921                                                    }
7922                                                  else
7923                                                    {
7924                                                      if (((word >> 13) & 0x1) == 0)
7925                                                        {
7926                                                          /* 33222222222211111111110000000000
7927                                                             10987654321098765432109876543210
7928                                                             xxxxxxxxxx101010xxxxx1xx1x100000
7929                                                             trn2.  */
7930                                                          return 1896;
7931                                                        }
7932                                                      else
7933                                                        {
7934                                                          /* 33222222222211111111110000000000
7935                                                             10987654321098765432109876543210
7936                                                             xxxxxxxxxx101110xxxxx1xx1x100000
7937                                                             trn2.  */
7938                                                          return 1897;
7939                                                        }
7940                                                    }
7941                                                }
7942                                              else
7943                                                {
7944                                                  if (((word >> 13) & 0x1) == 0)
7945                                                    {
7946                                                      /* 33222222222211111111110000000000
7947                                                         10987654321098765432109876543210
7948                                                         xxxxxxxxxx11x010xxxxx1xx1x100000
7949                                                         uzp2.  */
7950                                                      return 1958;
7951                                                    }
7952                                                  else
7953                                                    {
7954                                                      /* 33222222222211111111110000000000
7955                                                         10987654321098765432109876543210
7956                                                         xxxxxxxxxx11x110xxxxx1xx1x100000
7957                                                         uzp2.  */
7958                                                      return 1959;
7959                                                    }
7960                                                }
7961                                            }
7962                                        }
7963                                      else
7964                                        {
7965                                          /* 33222222222211111111110000000000
7966                                             10987654321098765432109876543210
7967                                             xxxxxxxxxxxxxx11xxxxx1xx1x100000
7968                                             sel.  */
7969                                          return 1760;
7970                                        }
7971                                    }
7972                                }
7973                            }
7974                          else
7975                            {
7976                              if (((word >> 13) & 0x1) == 0)
7977                                {
7978                                  if (((word >> 14) & 0x1) == 0)
7979                                    {
7980                                      if (((word >> 15) & 0x1) == 0)
7981                                        {
7982                                          if (((word >> 22) & 0x1) == 0)
7983                                            {
7984                                              /* 33222222222211111111110000000000
7985                                                 10987654321098765432109876543210
7986                                                 xxxxxxxxxxxxx000xxxxxx0x1x100001
7987                                                 ldr.  */
7988                                              return 1664;
7989                                            }
7990                                          else
7991                                            {
7992                                              /* 33222222222211111111110000000000
7993                                                 10987654321098765432109876543210
7994                                                 xxxxxxxxxxxxx000xxxxxx1x1x100001
7995                                                 prfb.  */
7996                                              return 1708;
7997                                            }
7998                                        }
7999                                      else
8000                                        {
8001                                          if (((word >> 23) & 0x1) == 0)
8002                                            {
8003                                              /* 33222222222211111111110000000000
8004                                                 10987654321098765432109876543210
8005                                                 xxxxxxxxxxxxx001xxxxxxx01x100001
8006                                                 ld1rsh.  */
8007                                              return 1509;
8008                                            }
8009                                          else
8010                                            {
8011                                              /* 33222222222211111111110000000000
8012                                                 10987654321098765432109876543210
8013                                                 xxxxxxxxxxxxx001xxxxxxx11x100001
8014                                                 ld1rsb.  */
8015                                              return 1506;
8016                                            }
8017                                        }
8018                                    }
8019                                  else
8020                                    {
8021                                      if (((word >> 15) & 0x1) == 0)
8022                                        {
8023                                          if (((word >> 23) & 0x1) == 0)
8024                                            {
8025                                              if (((word >> 21) & 0x1) == 0)
8026                                                {
8027                                                  /* 33222222222211111111110000000000
8028                                                     10987654321098765432109876543210
8029                                                     xxxxxxxxxxxxx010xxxxx0x01x100001
8030                                                     ld1w.  */
8031                                                  return 1544;
8032                                                }
8033                                              else
8034                                                {
8035                                                  /* 33222222222211111111110000000000
8036                                                     10987654321098765432109876543210
8037                                                     xxxxxxxxxxxxx010xxxxx1x01x100001
8038                                                     ld1w.  */
8039                                                  return 1545;
8040                                                }
8041                                            }
8042                                          else
8043                                            {
8044                                              if (((word >> 22) & 0x1) == 0)
8045                                                {
8046                                                  /* 33222222222211111111110000000000
8047                                                     10987654321098765432109876543210
8048                                                     xxxxxxxxxxxxx010xxxxxx011x100001
8049                                                     ldr.  */
8050                                                  return 1665;
8051                                                }
8052                                              else
8053                                                {
8054                                                  /* 33222222222211111111110000000000
8055                                                     10987654321098765432109876543210
8056                                                     xxxxxxxxxxxxx010xxxxxx111x100001
8057                                                     prfw.  */
8058                                                  return 1729;
8059                                                }
8060                                            }
8061                                        }
8062                                      else
8063                                        {
8064                                          if (((word >> 22) & 0x1) == 0)
8065                                            {
8066                                              if (((word >> 21) & 0x1) == 0)
8067                                                {
8068                                                  if (((word >> 23) & 0x1) == 0)
8069                                                    {
8070                                                      /* 33222222222211111111110000000000
8071                                                         10987654321098765432109876543210
8072                                                         xxxxxxxxxxxxx011xxxxx0001x100001
8073                                                         prfw.  */
8074                                                      return 1725;
8075                                                    }
8076                                                  else
8077                                                    {
8078                                                      /* 33222222222211111111110000000000
8079                                                         10987654321098765432109876543210
8080                                                         xxxxxxxxxxxxx011xxxxx0011x100001
8081                                                         prfd.  */
8082                                                      return 1711;
8083                                                    }
8084                                                }
8085                                              else
8086                                                {
8087                                                  /* 33222222222211111111110000000000
8088                                                     10987654321098765432109876543210
8089                                                     xxxxxxxxxxxxx011xxxxx10x1x100001
8090                                                     ld1w.  */
8091                                                  return 1552;
8092                                                }
8093                                            }
8094                                          else
8095                                            {
8096                                              if (((word >> 23) & 0x1) == 0)
8097                                                {
8098                                                  /* 33222222222211111111110000000000
8099                                                     10987654321098765432109876543210
8100                                                     xxxxxxxxxxxxx011xxxxxx101x100001
8101                                                     ld1rw.  */
8102                                                  return 1512;
8103                                                }
8104                                              else
8105                                                {
8106                                                  /* 33222222222211111111110000000000
8107                                                     10987654321098765432109876543210
8108                                                     xxxxxxxxxxxxx011xxxxxx111x100001
8109                                                     ld1rsb.  */
8110                                                  return 1508;
8111                                                }
8112                                            }
8113                                        }
8114                                    }
8115                                }
8116                              else
8117                                {
8118                                  if (((word >> 14) & 0x1) == 0)
8119                                    {
8120                                      if (((word >> 15) & 0x1) == 0)
8121                                        {
8122                                          /* 33222222222211111111110000000000
8123                                             10987654321098765432109876543210
8124                                             xxxxxxxxxxxxx100xxxxxxxx1x100001
8125                                             prfh.  */
8126                                          return 1722;
8127                                        }
8128                                      else
8129                                        {
8130                                          if (((word >> 23) & 0x1) == 0)
8131                                            {
8132                                              /* 33222222222211111111110000000000
8133                                                 10987654321098765432109876543210
8134                                                 xxxxxxxxxxxxx101xxxxxxx01x100001
8135                                                 ld1rsh.  */
8136                                              return 1510;
8137                                            }
8138                                          else
8139                                            {
8140                                              /* 33222222222211111111110000000000
8141                                                 10987654321098765432109876543210
8142                                                 xxxxxxxxxxxxx101xxxxxxx11x100001
8143                                                 ld1rsb.  */
8144                                              return 1507;
8145                                            }
8146                                        }
8147                                    }
8148                                  else
8149                                    {
8150                                      if (((word >> 15) & 0x1) == 0)
8151                                        {
8152                                          if (((word >> 23) & 0x1) == 0)
8153                                            {
8154                                              if (((word >> 21) & 0x1) == 0)
8155                                                {
8156                                                  /* 33222222222211111111110000000000
8157                                                     10987654321098765432109876543210
8158                                                     xxxxxxxxxxxxx110xxxxx0x01x100001
8159                                                     ldff1w.  */
8160                                                  return 1630;
8161                                                }
8162                                              else
8163                                                {
8164                                                  /* 33222222222211111111110000000000
8165                                                     10987654321098765432109876543210
8166                                                     xxxxxxxxxxxxx110xxxxx1x01x100001
8167                                                     ldff1w.  */
8168                                                  return 1631;
8169                                                }
8170                                            }
8171                                          else
8172                                            {
8173                                              /* 33222222222211111111110000000000
8174                                                 10987654321098765432109876543210
8175                                                 xxxxxxxxxxxxx110xxxxxxx11x100001
8176                                                 prfd.  */
8177                                              return 1715;
8178                                            }
8179                                        }
8180                                      else
8181                                        {
8182                                          if (((word >> 22) & 0x1) == 0)
8183                                            {
8184                                              if (((word >> 21) & 0x1) == 0)
8185                                                {
8186                                                  if (((word >> 23) & 0x1) == 0)
8187                                                    {
8188                                                      /* 33222222222211111111110000000000
8189                                                         10987654321098765432109876543210
8190                                                         xxxxxxxxxxxxx111xxxxx0001x100001
8191                                                         prfw.  */
8192                                                      return 1728;
8193                                                    }
8194                                                  else
8195                                                    {
8196                                                      /* 33222222222211111111110000000000
8197                                                         10987654321098765432109876543210
8198                                                         xxxxxxxxxxxxx111xxxxx0011x100001
8199                                                         prfd.  */
8200                                                      return 1714;
8201                                                    }
8202                                                }
8203                                              else
8204                                                {
8205                                                  /* 33222222222211111111110000000000
8206                                                     10987654321098765432109876543210
8207                                                     xxxxxxxxxxxxx111xxxxx10x1x100001
8208                                                     ldff1w.  */
8209                                                  return 1638;
8210                                                }
8211                                            }
8212                                          else
8213                                            {
8214                                              if (((word >> 23) & 0x1) == 0)
8215                                                {
8216                                                  /* 33222222222211111111110000000000
8217                                                     10987654321098765432109876543210
8218                                                     xxxxxxxxxxxxx111xxxxxx101x100001
8219                                                     ld1rw.  */
8220                                                  return 1513;
8221                                                }
8222                                              else
8223                                                {
8224                                                  /* 33222222222211111111110000000000
8225                                                     10987654321098765432109876543210
8226                                                     xxxxxxxxxxxxx111xxxxxx111x100001
8227                                                     ld1rd.  */
8228                                                  return 1494;
8229                                                }
8230                                            }
8231                                        }
8232                                    }
8233                                }
8234                            }
8235                        }
8236                      else
8237                        {
8238                          if (((word >> 13) & 0x1) == 0)
8239                            {
8240                              if (((word >> 14) & 0x1) == 0)
8241                                {
8242                                  if (((word >> 15) & 0x1) == 0)
8243                                    {
8244                                      if (((word >> 21) & 0x1) == 0)
8245                                        {
8246                                          /* 33222222222211111111110000000000
8247                                             10987654321098765432109876543210
8248                                             xxxxxxxxxxxxx000xxxxx0xx1x10001x
8249                                             ld1sw.  */
8250                                          return 1538;
8251                                        }
8252                                      else
8253                                        {
8254                                          /* 33222222222211111111110000000000
8255                                             10987654321098765432109876543210
8256                                             xxxxxxxxxxxxx000xxxxx1xx1x10001x
8257                                             ld1sw.  */
8258                                          return 1539;
8259                                        }
8260                                    }
8261                                  else
8262                                    {
8263                                      if (((word >> 21) & 0x1) == 0)
8264                                        {
8265                                          /* 33222222222211111111110000000000
8266                                             10987654321098765432109876543210
8267                                             xxxxxxxxxxxxx001xxxxx0xx1x10001x
8268                                             ld1sw.  */
8269                                          return 1540;
8270                                        }
8271                                      else
8272                                        {
8273                                          if (((word >> 22) & 0x1) == 0)
8274                                            {
8275                                              /* 33222222222211111111110000000000
8276                                                 10987654321098765432109876543210
8277                                                 xxxxxxxxxxxxx001xxxxx10x1x10001x
8278                                                 ld1sw.  */
8279                                              return 1543;
8280                                            }
8281                                          else
8282                                            {
8283                                              /* 33222222222211111111110000000000
8284                                                 10987654321098765432109876543210
8285                                                 xxxxxxxxxxxxx001xxxxx11x1x10001x
8286                                                 ld1sw.  */
8287                                              return 1541;
8288                                            }
8289                                        }
8290                                    }
8291                                }
8292                              else
8293                                {
8294                                  if (((word >> 15) & 0x1) == 0)
8295                                    {
8296                                      if (((word >> 21) & 0x1) == 0)
8297                                        {
8298                                          if (((word >> 23) & 0x1) == 0)
8299                                            {
8300                                              /* 33222222222211111111110000000000
8301                                                 10987654321098765432109876543210
8302                                                 xxxxxxxxxxxxx010xxxxx0x01x10001x
8303                                                 ld1w.  */
8304                                              return 1548;
8305                                            }
8306                                          else
8307                                            {
8308                                              /* 33222222222211111111110000000000
8309                                                 10987654321098765432109876543210
8310                                                 xxxxxxxxxxxxx010xxxxx0x11x10001x
8311                                                 ld1d.  */
8312                                              return 1470;
8313                                            }
8314                                        }
8315                                      else
8316                                        {
8317                                          if (((word >> 23) & 0x1) == 0)
8318                                            {
8319                                              /* 33222222222211111111110000000000
8320                                                 10987654321098765432109876543210
8321                                                 xxxxxxxxxxxxx010xxxxx1x01x10001x
8322                                                 ld1w.  */
8323                                              return 1549;
8324                                            }
8325                                          else
8326                                            {
8327                                              /* 33222222222211111111110000000000
8328                                                 10987654321098765432109876543210
8329                                                 xxxxxxxxxxxxx010xxxxx1x11x10001x
8330                                                 ld1d.  */
8331                                              return 1471;
8332                                            }
8333                                        }
8334                                    }
8335                                  else
8336                                    {
8337                                      if (((word >> 21) & 0x1) == 0)
8338                                        {
8339                                          if (((word >> 23) & 0x1) == 0)
8340                                            {
8341                                              /* 33222222222211111111110000000000
8342                                                 10987654321098765432109876543210
8343                                                 xxxxxxxxxxxxx011xxxxx0x01x10001x
8344                                                 ld1w.  */
8345                                              return 1550;
8346                                            }
8347                                          else
8348                                            {
8349                                              /* 33222222222211111111110000000000
8350                                                 10987654321098765432109876543210
8351                                                 xxxxxxxxxxxxx011xxxxx0x11x10001x
8352                                                 ld1d.  */
8353                                              return 1472;
8354                                            }
8355                                        }
8356                                      else
8357                                        {
8358                                          if (((word >> 22) & 0x1) == 0)
8359                                            {
8360                                              if (((word >> 23) & 0x1) == 0)
8361                                                {
8362                                                  /* 33222222222211111111110000000000
8363                                                     10987654321098765432109876543210
8364                                                     xxxxxxxxxxxxx011xxxxx1001x10001x
8365                                                     ld1w.  */
8366                                                  return 1555;
8367                                                }
8368                                              else
8369                                                {
8370                                                  /* 33222222222211111111110000000000
8371                                                     10987654321098765432109876543210
8372                                                     xxxxxxxxxxxxx011xxxxx1011x10001x
8373                                                     ld1d.  */
8374                                                  return 1475;
8375                                                }
8376                                            }
8377                                          else
8378                                            {
8379                                              if (((word >> 23) & 0x1) == 0)
8380                                                {
8381                                                  /* 33222222222211111111110000000000
8382                                                     10987654321098765432109876543210
8383                                                     xxxxxxxxxxxxx011xxxxx1101x10001x
8384                                                     ld1w.  */
8385                                                  return 1551;
8386                                                }
8387                                              else
8388                                                {
8389                                                  /* 33222222222211111111110000000000
8390                                                     10987654321098765432109876543210
8391                                                     xxxxxxxxxxxxx011xxxxx1111x10001x
8392                                                     ld1d.  */
8393                                                  return 1473;
8394                                                }
8395                                            }
8396                                        }
8397                                    }
8398                                }
8399                            }
8400                          else
8401                            {
8402                              if (((word >> 14) & 0x1) == 0)
8403                                {
8404                                  if (((word >> 15) & 0x1) == 0)
8405                                    {
8406                                      if (((word >> 21) & 0x1) == 0)
8407                                        {
8408                                          /* 33222222222211111111110000000000
8409                                             10987654321098765432109876543210
8410                                             xxxxxxxxxxxxx100xxxxx0xx1x10001x
8411                                             ldff1sw.  */
8412                                          return 1625;
8413                                        }
8414                                      else
8415                                        {
8416                                          /* 33222222222211111111110000000000
8417                                             10987654321098765432109876543210
8418                                             xxxxxxxxxxxxx100xxxxx1xx1x10001x
8419                                             ldff1sw.  */
8420                                          return 1626;
8421                                        }
8422                                    }
8423                                  else
8424                                    {
8425                                      if (((word >> 21) & 0x1) == 0)
8426                                        {
8427                                          /* 33222222222211111111110000000000
8428                                             10987654321098765432109876543210
8429                                             xxxxxxxxxxxxx101xxxxx0xx1x10001x
8430                                             ldff1sw.  */
8431                                          return 1627;
8432                                        }
8433                                      else
8434                                        {
8435                                          if (((word >> 22) & 0x1) == 0)
8436                                            {
8437                                              /* 33222222222211111111110000000000
8438                                                 10987654321098765432109876543210
8439                                                 xxxxxxxxxxxxx101xxxxx10x1x10001x
8440                                                 ldff1sw.  */
8441                                              return 1629;
8442                                            }
8443                                          else
8444                                            {
8445                                              /* 33222222222211111111110000000000
8446                                                 10987654321098765432109876543210
8447                                                 xxxxxxxxxxxxx101xxxxx11x1x10001x
8448                                                 ldff1sw.  */
8449                                              return 1628;
8450                                            }
8451                                        }
8452                                    }
8453                                }
8454                              else
8455                                {
8456                                  if (((word >> 15) & 0x1) == 0)
8457                                    {
8458                                      if (((word >> 21) & 0x1) == 0)
8459                                        {
8460                                          if (((word >> 23) & 0x1) == 0)
8461                                            {
8462                                              /* 33222222222211111111110000000000
8463                                                 10987654321098765432109876543210
8464                                                 xxxxxxxxxxxxx110xxxxx0x01x10001x
8465                                                 ldff1w.  */
8466                                              return 1634;
8467                                            }
8468                                          else
8469                                            {
8470                                              /* 33222222222211111111110000000000
8471                                                 10987654321098765432109876543210
8472                                                 xxxxxxxxxxxxx110xxxxx0x11x10001x
8473                                                 ldff1d.  */
8474                                              return 1590;
8475                                            }
8476                                        }
8477                                      else
8478                                        {
8479                                          if (((word >> 23) & 0x1) == 0)
8480                                            {
8481                                              /* 33222222222211111111110000000000
8482                                                 10987654321098765432109876543210
8483                                                 xxxxxxxxxxxxx110xxxxx1x01x10001x
8484                                                 ldff1w.  */
8485                                              return 1635;
8486                                            }
8487                                          else
8488                                            {
8489                                              /* 33222222222211111111110000000000
8490                                                 10987654321098765432109876543210
8491                                                 xxxxxxxxxxxxx110xxxxx1x11x10001x
8492                                                 ldff1d.  */
8493                                              return 1591;
8494                                            }
8495                                        }
8496                                    }
8497                                  else
8498                                    {
8499                                      if (((word >> 21) & 0x1) == 0)
8500                                        {
8501                                          if (((word >> 22) & 0x1) == 0)
8502                                            {
8503                                              if (((word >> 23) & 0x1) == 0)
8504                                                {
8505                                                  /* 33222222222211111111110000000000
8506                                                     10987654321098765432109876543210
8507                                                     xxxxxxxxxxxxx111xxxxx0001x10001x
8508                                                     prfw.  */
8509                                                  return 1730;
8510                                                }
8511                                              else
8512                                                {
8513                                                  /* 33222222222211111111110000000000
8514                                                     10987654321098765432109876543210
8515                                                     xxxxxxxxxxxxx111xxxxx0011x10001x
8516                                                     prfd.  */
8517                                                  return 1716;
8518                                                }
8519                                            }
8520                                          else
8521                                            {
8522                                              if (((word >> 23) & 0x1) == 0)
8523                                                {
8524                                                  /* 33222222222211111111110000000000
8525                                                     10987654321098765432109876543210
8526                                                     xxxxxxxxxxxxx111xxxxx0101x10001x
8527                                                     ldff1w.  */
8528                                                  return 1636;
8529                                                }
8530                                              else
8531                                                {
8532                                                  /* 33222222222211111111110000000000
8533                                                     10987654321098765432109876543210
8534                                                     xxxxxxxxxxxxx111xxxxx0111x10001x
8535                                                     ldff1d.  */
8536                                                  return 1592;
8537                                                }
8538                                            }
8539                                        }
8540                                      else
8541                                        {
8542                                          if (((word >> 22) & 0x1) == 0)
8543                                            {
8544                                              if (((word >> 23) & 0x1) == 0)
8545                                                {
8546                                                  /* 33222222222211111111110000000000
8547                                                     10987654321098765432109876543210
8548                                                     xxxxxxxxxxxxx111xxxxx1001x10001x
8549                                                     ldff1w.  */
8550                                                  return 1639;
8551                                                }
8552                                              else
8553                                                {
8554                                                  /* 33222222222211111111110000000000
8555                                                     10987654321098765432109876543210
8556                                                     xxxxxxxxxxxxx111xxxxx1011x10001x
8557                                                     ldff1d.  */
8558                                                  return 1594;
8559                                                }
8560                                            }
8561                                          else
8562                                            {
8563                                              if (((word >> 23) & 0x1) == 0)
8564                                                {
8565                                                  /* 33222222222211111111110000000000
8566                                                     10987654321098765432109876543210
8567                                                     xxxxxxxxxxxxx111xxxxx1101x10001x
8568                                                     ldff1w.  */
8569                                                  return 1637;
8570                                                }
8571                                              else
8572                                                {
8573                                                  /* 33222222222211111111110000000000
8574                                                     10987654321098765432109876543210
8575                                                     xxxxxxxxxxxxx111xxxxx1111x10001x
8576                                                     ldff1d.  */
8577                                                  return 1593;
8578                                                }
8579                                            }
8580                                        }
8581                                    }
8582                                }
8583                            }
8584                        }
8585                    }
8586                  else
8587                    {
8588                      if (((word >> 15) & 0x1) == 0)
8589                        {
8590                          if (((word >> 14) & 0x1) == 0)
8591                            {
8592                              if (((word >> 13) & 0x1) == 0)
8593                                {
8594                                  if (((word >> 30) & 0x1) == 0)
8595                                    {
8596                                      if (((word >> 21) & 0x1) == 0)
8597                                        {
8598                                          if (((word >> 31) & 0x1) == 0)
8599                                            {
8600                                              if (((word >> 4) & 0x1) == 0)
8601                                                {
8602                                                  /* 33222222222211111111110000000000
8603                                                     10987654321098765432109876543210
8604                                                     xxxx0xxxxxxxx000xxxxx0xx1x100100
8605                                                     cmpge.  */
8606                                                  return 1278;
8607                                                }
8608                                              else
8609                                                {
8610                                                  /* 33222222222211111111110000000000
8611                                                     10987654321098765432109876543210
8612                                                     xxxx1xxxxxxxx000xxxxx0xx1x100100
8613                                                     cmpgt.  */
8614                                                  return 1281;
8615                                                }
8616                                            }
8617                                          else
8618                                            {
8619                                              if (((word >> 23) & 0x1) == 0)
8620                                                {
8621                                                  /* 33222222222211111111110000000000
8622                                                     10987654321098765432109876543210
8623                                                     xxxxxxxxxxxxx000xxxxx0x01x100101
8624                                                     ld1rqw.  */
8625                                                  return 1505;
8626                                                }
8627                                              else
8628                                                {
8629                                                  /* 33222222222211111111110000000000
8630                                                     10987654321098765432109876543210
8631                                                     xxxxxxxxxxxxx000xxxxx0x11x100101
8632                                                     ld1rqd.  */
8633                                                  return 1501;
8634                                                }
8635                                            }
8636                                        }
8637                                      else
8638                                        {
8639                                          if (((word >> 4) & 0x1) == 0)
8640                                            {
8641                                              if (((word >> 11) & 0x1) == 0)
8642                                                {
8643                                                  if (((word >> 12) & 0x1) == 0)
8644                                                    {
8645                                                      /* 33222222222211111111110000000000
8646                                                         10987654321098765432109876543210
8647                                                         xxxx0xxxxxx00000xxxxx1xx1x10010x
8648                                                         whilelt.  */
8649                                                      return 1966;
8650                                                    }
8651                                                  else
8652                                                    {
8653                                                      /* 33222222222211111111110000000000
8654                                                         10987654321098765432109876543210
8655                                                         xxxx0xxxxxx01000xxxxx1xx1x10010x
8656                                                         whilelt.  */
8657                                                      return 1967;
8658                                                    }
8659                                                }
8660                                              else
8661                                                {
8662                                                  if (((word >> 12) & 0x1) == 0)
8663                                                    {
8664                                                      /* 33222222222211111111110000000000
8665                                                         10987654321098765432109876543210
8666                                                         xxxx0xxxxxx10000xxxxx1xx1x10010x
8667                                                         whilelo.  */
8668                                                      return 1962;
8669                                                    }
8670                                                  else
8671                                                    {
8672                                                      /* 33222222222211111111110000000000
8673                                                         10987654321098765432109876543210
8674                                                         xxxx0xxxxxx11000xxxxx1xx1x10010x
8675                                                         whilelo.  */
8676                                                      return 1963;
8677                                                    }
8678                                                }
8679                                            }
8680                                          else
8681                                            {
8682                                              if (((word >> 11) & 0x1) == 0)
8683                                                {
8684                                                  if (((word >> 12) & 0x1) == 0)
8685                                                    {
8686                                                      /* 33222222222211111111110000000000
8687                                                         10987654321098765432109876543210
8688                                                         xxxx1xxxxxx00000xxxxx1xx1x10010x
8689                                                         whilele.  */
8690                                                      return 1960;
8691                                                    }
8692                                                  else
8693                                                    {
8694                                                      /* 33222222222211111111110000000000
8695                                                         10987654321098765432109876543210
8696                                                         xxxx1xxxxxx01000xxxxx1xx1x10010x
8697                                                         whilele.  */
8698                                                      return 1961;
8699                                                    }
8700                                                }
8701                                              else
8702                                                {
8703                                                  if (((word >> 12) & 0x1) == 0)
8704                                                    {
8705                                                      /* 33222222222211111111110000000000
8706                                                         10987654321098765432109876543210
8707                                                         xxxx1xxxxxx10000xxxxx1xx1x10010x
8708                                                         whilels.  */
8709                                                      return 1964;
8710                                                    }
8711                                                  else
8712                                                    {
8713                                                      /* 33222222222211111111110000000000
8714                                                         10987654321098765432109876543210
8715                                                         xxxx1xxxxxx11000xxxxx1xx1x10010x
8716                                                         whilels.  */
8717                                                      return 1965;
8718                                                    }
8719                                                }
8720                                            }
8721                                        }
8722                                    }
8723                                  else
8724                                    {
8725                                      if (((word >> 31) & 0x1) == 0)
8726                                        {
8727                                          if (((word >> 21) & 0x1) == 0)
8728                                            {
8729                                              if (((word >> 10) & 0x1) == 0)
8730                                                {
8731                                                  if (((word >> 11) & 0x1) == 0)
8732                                                    {
8733                                                      /* 33222222222211111111110000000000
8734                                                         10987654321098765432109876543210
8735                                                         xxxxxxxxxx00x000xxxxx0xx1x100110
8736                                                         fadd.  */
8737                                                      return 1336;
8738                                                    }
8739                                                  else
8740                                                    {
8741                                                      if (((word >> 12) & 0x1) == 0)
8742                                                        {
8743                                                          /* 33222222222211111111110000000000
8744                                                             10987654321098765432109876543210
8745                                                             xxxxxxxxxx010000xxxxx0xx1x100110
8746                                                             fmul.  */
8747                                                          return 1403;
8748                                                        }
8749                                                      else
8750                                                        {
8751                                                          /* 33222222222211111111110000000000
8752                                                             10987654321098765432109876543210
8753                                                             xxxxxxxxxx011000xxxxx0xx1x100110
8754                                                             frecps.  */
8755                                                          return 1416;
8756                                                        }
8757                                                    }
8758                                                }
8759                                              else
8760                                                {
8761                                                  if (((word >> 11) & 0x1) == 0)
8762                                                    {
8763                                                      /* 33222222222211111111110000000000
8764                                                         10987654321098765432109876543210
8765                                                         xxxxxxxxxx10x000xxxxx0xx1x100110
8766                                                         fsub.  */
8767                                                      return 1429;
8768                                                    }
8769                                                  else
8770                                                    {
8771                                                      if (((word >> 12) & 0x1) == 0)
8772                                                        {
8773                                                          /* 33222222222211111111110000000000
8774                                                             10987654321098765432109876543210
8775                                                             xxxxxxxxxx110000xxxxx0xx1x100110
8776                                                             ftsmul.  */
8777                                                          return 1435;
8778                                                        }
8779                                                      else
8780                                                        {
8781                                                          /* 33222222222211111111110000000000
8782                                                             10987654321098765432109876543210
8783                                                             xxxxxxxxxx111000xxxxx0xx1x100110
8784                                                             frsqrts.  */
8785                                                          return 1426;
8786                                                        }
8787                                                    }
8788                                                }
8789                                            }
8790                                          else
8791                                            {
8792                                              /* 33222222222211111111110000000000
8793                                                 10987654321098765432109876543210
8794                                                 xxxxxxxxxxxxx000xxxxx1xx1x100110
8795                                                 fmla.  */
8796                                              return 1394;
8797                                            }
8798                                        }
8799                                      else
8800                                        {
8801                                          /* 33222222222211111111110000000000
8802                                             10987654321098765432109876543210
8803                                             xxxxxxxxxxxxx000xxxxxxxx1x100111
8804                                             str.  */
8805                                          return 1881;
8806                                        }
8807                                    }
8808                                }
8809                              else
8810                                {
8811                                  if (((word >> 21) & 0x1) == 0)
8812                                    {
8813                                      if (((word >> 30) & 0x1) == 0)
8814                                        {
8815                                          if (((word >> 31) & 0x1) == 0)
8816                                            {
8817                                              if (((word >> 4) & 0x1) == 0)
8818                                                {
8819                                                  /* 33222222222211111111110000000000
8820                                                     10987654321098765432109876543210
8821                                                     xxxx0xxxxxxxx100xxxxx0xx1x100100
8822                                                     cmplt.  */
8823                                                  return 1295;
8824                                                }
8825                                              else
8826                                                {
8827                                                  /* 33222222222211111111110000000000
8828                                                     10987654321098765432109876543210
8829                                                     xxxx1xxxxxxxx100xxxxx0xx1x100100
8830                                                     cmple.  */
8831                                                  return 1289;
8832                                                }
8833                                            }
8834                                          else
8835                                            {
8836                                              if (((word >> 23) & 0x1) == 0)
8837                                                {
8838                                                  /* 33222222222211111111110000000000
8839                                                     10987654321098765432109876543210
8840                                                     xxxxxxxxxxxxx100xxxxx0x01x100101
8841                                                     ld1rqw.  */
8842                                                  return 1504;
8843                                                }
8844                                              else
8845                                                {
8846                                                  /* 33222222222211111111110000000000
8847                                                     10987654321098765432109876543210
8848                                                     xxxxxxxxxxxxx100xxxxx0x11x100101
8849                                                     ld1rqd.  */
8850                                                  return 1500;
8851                                                }
8852                                            }
8853                                        }
8854                                      else
8855                                        {
8856                                          if (((word >> 16) & 0x1) == 0)
8857                                            {
8858                                              if (((word >> 17) & 0x1) == 0)
8859                                                {
8860                                                  if (((word >> 18) & 0x1) == 0)
8861                                                    {
8862                                                      if (((word >> 19) & 0x1) == 0)
8863                                                        {
8864                                                          if (((word >> 20) & 0x1) == 0)
8865                                                            {
8866                                                              /* 33222222222211111111110000000000
8867                                                                 10987654321098765432109876543210
8868                                                                 xxxxxxxxxxxxx100000000xx1x10011x
8869                                                                 faddv.  */
8870                                                              return 1340;
8871                                                            }
8872                                                          else
8873                                                            {
8874                                                              if (((word >> 4) & 0x1) == 0)
8875                                                                {
8876                                                                  /* 33222222222211111111110000000000
8877                                                                     10987654321098765432109876543210
8878                                                                     xxxx0xxxxxxxx100000010xx1x10011x
8879                                                                     fcmge.  */
8880                                                                  return 1347;
8881                                                                }
8882                                                              else
8883                                                                {
8884                                                                  /* 33222222222211111111110000000000
8885                                                                     10987654321098765432109876543210
8886                                                                     xxxx1xxxxxxxx100000010xx1x10011x
8887                                                                     fcmgt.  */
8888                                                                  return 1349;
8889                                                                }
8890                                                            }
8891                                                        }
8892                                                      else
8893                                                        {
8894                                                          /* 33222222222211111111110000000000
8895                                                             10987654321098765432109876543210
8896                                                             xxxxxxxxxxxxx1000001x0xx1x10011x
8897                                                             fadda.  */
8898                                                          return 1339;
8899                                                        }
8900                                                    }
8901                                                  else
8902                                                    {
8903                                                      /* 33222222222211111111110000000000
8904                                                         10987654321098765432109876543210
8905                                                         xxxxxxxxxxxxx100001xx0xx1x10011x
8906                                                         fmaxnmv.  */
8907                                                      return 1386;
8908                                                    }
8909                                                }
8910                                              else
8911                                                {
8912                                                  if (((word >> 18) & 0x1) == 0)
8913                                                    {
8914                                                      /* 33222222222211111111110000000000
8915                                                         10987654321098765432109876543210
8916                                                         xxxxxxxxxxxxx100010xx0xx1x10011x
8917                                                         fcmeq.  */
8918                                                      return 1345;
8919                                                    }
8920                                                  else
8921                                                    {
8922                                                      if (((word >> 19) & 0x1) == 0)
8923                                                        {
8924                                                          /* 33222222222211111111110000000000
8925                                                             10987654321098765432109876543210
8926                                                             xxxxxxxxxxxxx1000110x0xx1x10011x
8927                                                             fmaxv.  */
8928                                                          return 1387;
8929                                                        }
8930                                                      else
8931                                                        {
8932                                                          /* 33222222222211111111110000000000
8933                                                             10987654321098765432109876543210
8934                                                             xxxxxxxxxxxxx1000111x0xx1x10011x
8935                                                             frecpe.  */
8936                                                          return 1415;
8937                                                        }
8938                                                    }
8939                                                }
8940                                            }
8941                                          else
8942                                            {
8943                                              if (((word >> 17) & 0x1) == 0)
8944                                                {
8945                                                  if (((word >> 18) & 0x1) == 0)
8946                                                    {
8947                                                      if (((word >> 4) & 0x1) == 0)
8948                                                        {
8949                                                          /* 33222222222211111111110000000000
8950                                                             10987654321098765432109876543210
8951                                                             xxxx0xxxxxxxx100100xx0xx1x10011x
8952                                                             fcmlt.  */
8953                                                          return 1352;
8954                                                        }
8955                                                      else
8956                                                        {
8957                                                          /* 33222222222211111111110000000000
8958                                                             10987654321098765432109876543210
8959                                                             xxxx1xxxxxxxx100100xx0xx1x10011x
8960                                                             fcmle.  */
8961                                                          return 1351;
8962                                                        }
8963                                                    }
8964                                                  else
8965                                                    {
8966                                                      /* 33222222222211111111110000000000
8967                                                         10987654321098765432109876543210
8968                                                         xxxxxxxxxxxxx100101xx0xx1x10011x
8969                                                         fminnmv.  */
8970                                                      return 1392;
8971                                                    }
8972                                                }
8973                                              else
8974                                                {
8975                                                  if (((word >> 18) & 0x1) == 0)
8976                                                    {
8977                                                      /* 33222222222211111111110000000000
8978                                                         10987654321098765432109876543210
8979                                                         xxxxxxxxxxxxx100110xx0xx1x10011x
8980                                                         fcmne.  */
8981                                                      return 1353;
8982                                                    }
8983                                                  else
8984                                                    {
8985                                                      if (((word >> 19) & 0x1) == 0)
8986                                                        {
8987                                                          /* 33222222222211111111110000000000
8988                                                             10987654321098765432109876543210
8989                                                             xxxxxxxxxxxxx1001110x0xx1x10011x
8990                                                             fminv.  */
8991                                                          return 1393;
8992                                                        }
8993                                                      else
8994                                                        {
8995                                                          /* 33222222222211111111110000000000
8996                                                             10987654321098765432109876543210
8997                                                             xxxxxxxxxxxxx1001111x0xx1x10011x
8998                                                             frsqrte.  */
8999                                                          return 1425;
9000                                                        }
9001                                                    }
9002                                                }
9003                                            }
9004                                        }
9005                                    }
9006                                  else
9007                                    {
9008                                      if (((word >> 30) & 0x1) == 0)
9009                                        {
9010                                          if (((word >> 4) & 0x1) == 0)
9011                                            {
9012                                              /* 33222222222211111111110000000000
9013                                                 10987654321098765432109876543210
9014                                                 xxxx0xxxxxxxx100xxxxx1xx1x10010x
9015                                                 ctermeq.  */
9016                                              return 1310;
9017                                            }
9018                                          else
9019                                            {
9020                                              /* 33222222222211111111110000000000
9021                                                 10987654321098765432109876543210
9022                                                 xxxx1xxxxxxxx100xxxxx1xx1x10010x
9023                                                 ctermne.  */
9024                                              return 1311;
9025                                            }
9026                                        }
9027                                      else
9028                                        {
9029                                          /* 33222222222211111111110000000000
9030                                             10987654321098765432109876543210
9031                                             xxxxxxxxxxxxx100xxxxx1xx1x10011x
9032                                             fmls.  */
9033                                          return 1398;
9034                                        }
9035                                    }
9036                                }
9037                            }
9038                          else
9039                            {
9040                              if (((word >> 30) & 0x1) == 0)
9041                                {
9042                                  if (((word >> 21) & 0x1) == 0)
9043                                    {
9044                                      if (((word >> 22) & 0x1) == 0)
9045                                        {
9046                                          if (((word >> 23) & 0x1) == 0)
9047                                            {
9048                                              if (((word >> 31) & 0x1) == 0)
9049                                                {
9050                                                  if (((word >> 9) & 0x1) == 0)
9051                                                    {
9052                                                      if (((word >> 20) & 0x1) == 0)
9053                                                        {
9054                                                          if (((word >> 4) & 0x1) == 0)
9055                                                            {
9056                                                              /* 33222222222211111111110000000000
9057                                                                 10987654321098765432109876543210
9058                                                                 xxxx0xxxx0xxxx10xxxx00001x100100
9059                                                                 and.  */
9060                                                              return 1241;
9061                                                            }
9062                                                          else
9063                                                            {
9064                                                              /* 33222222222211111111110000000000
9065                                                                 10987654321098765432109876543210
9066                                                                 xxxx1xxxx0xxxx10xxxx00001x100100
9067                                                                 bic.  */
9068                                                              return 1253;
9069                                                            }
9070                                                        }
9071                                                      else
9072                                                        {
9073                                                          if (((word >> 19) & 0x1) == 0)
9074                                                            {
9075                                                              /* 33222222222211111111110000000000
9076                                                                 10987654321098765432109876543210
9077                                                                 xxxxxxxxx0xxxx10xxx010001x100100
9078                                                                 brka.  */
9079                                                              return 1255;
9080                                                            }
9081                                                          else
9082                                                            {
9083                                                              /* 33222222222211111111110000000000
9084                                                                 10987654321098765432109876543210
9085                                                                 xxxxxxxxx0xxxx10xxx110001x100100
9086                                                                 brkn.  */
9087                                                              return 1259;
9088                                                            }
9089                                                        }
9090                                                    }
9091                                                  else
9092                                                    {
9093                                                      if (((word >> 4) & 0x1) == 0)
9094                                                        {
9095                                                          /* 33222222222211111111110000000000
9096                                                             10987654321098765432109876543210
9097                                                             xxxx0xxxx1xxxx10xxxxx0001x100100
9098                                                             eor.  */
9099                                                          return 1328;
9100                                                        }
9101                                                      else
9102                                                        {
9103                                                          /* 33222222222211111111110000000000
9104                                                             10987654321098765432109876543210
9105                                                             xxxx1xxxx1xxxx10xxxxx0001x100100
9106                                                             sel.  */
9107                                                          return 1761;
9108                                                        }
9109                                                    }
9110                                                }
9111                                              else
9112                                                {
9113                                                  if (((word >> 13) & 0x1) == 0)
9114                                                    {
9115                                                      /* 33222222222211111111110000000000
9116                                                         10987654321098765432109876543210
9117                                                         xxxxxxxxxxxxx010xxxxx0001x100101
9118                                                         ld1sh.  */
9119                                                      return 1527;
9120                                                    }
9121                                                  else
9122                                                    {
9123                                                      /* 33222222222211111111110000000000
9124                                                         10987654321098765432109876543210
9125                                                         xxxxxxxxxxxxx110xxxxx0001x100101
9126                                                         ldff1sh.  */
9127                                                      return 1616;
9128                                                    }
9129                                                }
9130                                            }
9131                                          else
9132                                            {
9133                                              if (((word >> 31) & 0x1) == 0)
9134                                                {
9135                                                  if (((word >> 9) & 0x1) == 0)
9136                                                    {
9137                                                      if (((word >> 20) & 0x1) == 0)
9138                                                        {
9139                                                          if (((word >> 4) & 0x1) == 0)
9140                                                            {
9141                                                              /* 33222222222211111111110000000000
9142                                                                 10987654321098765432109876543210
9143                                                                 xxxx0xxxx0xxxx10xxxx00011x100100
9144                                                                 orr.  */
9145                                                              return 1697;
9146                                                            }
9147                                                          else
9148                                                            {
9149                                                              /* 33222222222211111111110000000000
9150                                                                 10987654321098765432109876543210
9151                                                                 xxxx1xxxx0xxxx10xxxx00011x100100
9152                                                                 orn.  */
9153                                                              return 1692;
9154                                                            }
9155                                                        }
9156                                                      else
9157                                                        {
9158                                                          /* 33222222222211111111110000000000
9159                                                             10987654321098765432109876543210
9160                                                             xxxxxxxxx0xxxx10xxxx10011x100100
9161                                                             brkb.  */
9162                                                          return 1257;
9163                                                        }
9164                                                    }
9165                                                  else
9166                                                    {
9167                                                      if (((word >> 4) & 0x1) == 0)
9168                                                        {
9169                                                          /* 33222222222211111111110000000000
9170                                                             10987654321098765432109876543210
9171                                                             xxxx0xxxx1xxxx10xxxxx0011x100100
9172                                                             nor.  */
9173                                                          return 1689;
9174                                                        }
9175                                                      else
9176                                                        {
9177                                                          /* 33222222222211111111110000000000
9178                                                             10987654321098765432109876543210
9179                                                             xxxx1xxxx1xxxx10xxxxx0011x100100
9180                                                             nand.  */
9181                                                          return 1686;
9182                                                        }
9183                                                    }
9184                                                }
9185                                              else
9186                                                {
9187                                                  if (((word >> 13) & 0x1) == 0)
9188                                                    {
9189                                                      /* 33222222222211111111110000000000
9190                                                         10987654321098765432109876543210
9191                                                         xxxxxxxxxxxxx010xxxxx0011x100101
9192                                                         ld1sb.  */
9193                                                      return 1515;
9194                                                    }
9195                                                  else
9196                                                    {
9197                                                      /* 33222222222211111111110000000000
9198                                                         10987654321098765432109876543210
9199                                                         xxxxxxxxxxxxx110xxxxx0011x100101
9200                                                         ldff1sb.  */
9201                                                      return 1607;
9202                                                    }
9203                                                }
9204                                            }
9205                                        }
9206                                      else
9207                                        {
9208                                          if (((word >> 23) & 0x1) == 0)
9209                                            {
9210                                              if (((word >> 31) & 0x1) == 0)
9211                                                {
9212                                                  if (((word >> 4) & 0x1) == 0)
9213                                                    {
9214                                                      if (((word >> 9) & 0x1) == 0)
9215                                                        {
9216                                                          if (((word >> 20) & 0x1) == 0)
9217                                                            {
9218                                                              /* 33222222222211111111110000000000
9219                                                                 10987654321098765432109876543210
9220                                                                 xxxx0xxxx0xxxx10xxxx00101x100100
9221                                                                 ands.  */
9222                                                              return 1242;
9223                                                            }
9224                                                          else
9225                                                            {
9226                                                              if (((word >> 19) & 0x1) == 0)
9227                                                                {
9228                                                                  /* 33222222222211111111110000000000
9229                                                                     10987654321098765432109876543210
9230                                                                     xxxx0xxxx0xxxx10xxx010101x100100
9231                                                                     brkas.  */
9232                                                                  return 1256;
9233                                                                }
9234                                                              else
9235                                                                {
9236                                                                  /* 33222222222211111111110000000000
9237                                                                     10987654321098765432109876543210
9238                                                                     xxxx0xxxx0xxxx10xxx110101x100100
9239                                                                     brkns.  */
9240                                                                  return 1260;
9241                                                                }
9242                                                            }
9243                                                        }
9244                                                      else
9245                                                        {
9246                                                          /* 33222222222211111111110000000000
9247                                                             10987654321098765432109876543210
9248                                                             xxxx0xxxx1xxxx10xxxxx0101x100100
9249                                                             eors.  */
9250                                                          return 1329;
9251                                                        }
9252                                                    }
9253                                                  else
9254                                                    {
9255                                                      /* 33222222222211111111110000000000
9256                                                         10987654321098765432109876543210
9257                                                         xxxx1xxxxxxxxx10xxxxx0101x100100
9258                                                         bics.  */
9259                                                      return 1254;
9260                                                    }
9261                                                }
9262                                              else
9263                                                {
9264                                                  if (((word >> 13) & 0x1) == 0)
9265                                                    {
9266                                                      /* 33222222222211111111110000000000
9267                                                         10987654321098765432109876543210
9268                                                         xxxxxxxxxxxxx010xxxxx0101x100101
9269                                                         ld1w.  */
9270                                                      return 1546;
9271                                                    }
9272                                                  else
9273                                                    {
9274                                                      /* 33222222222211111111110000000000
9275                                                         10987654321098765432109876543210
9276                                                         xxxxxxxxxxxxx110xxxxx0101x100101
9277                                                         ldff1w.  */
9278                                                      return 1632;
9279                                                    }
9280                                                }
9281                                            }
9282                                          else
9283                                            {
9284                                              if (((word >> 31) & 0x1) == 0)
9285                                                {
9286                                                  if (((word >> 4) & 0x1) == 0)
9287                                                    {
9288                                                      if (((word >> 9) & 0x1) == 0)
9289                                                        {
9290                                                          if (((word >> 20) & 0x1) == 0)
9291                                                            {
9292                                                              /* 33222222222211111111110000000000
9293                                                                 10987654321098765432109876543210
9294                                                                 xxxx0xxxx0xxxx10xxxx00111x100100
9295                                                                 orrs.  */
9296                                                              return 1698;
9297                                                            }
9298                                                          else
9299                                                            {
9300                                                              /* 33222222222211111111110000000000
9301                                                                 10987654321098765432109876543210
9302                                                                 xxxx0xxxx0xxxx10xxxx10111x100100
9303                                                                 brkbs.  */
9304                                                              return 1258;
9305                                                            }
9306                                                        }
9307                                                      else
9308                                                        {
9309                                                          /* 33222222222211111111110000000000
9310                                                             10987654321098765432109876543210
9311                                                             xxxx0xxxx1xxxx10xxxxx0111x100100
9312                                                             nors.  */
9313                                                          return 1690;
9314                                                        }
9315                                                    }
9316                                                  else
9317                                                    {
9318                                                      if (((word >> 9) & 0x1) == 0)
9319                                                        {
9320                                                          /* 33222222222211111111110000000000
9321                                                             10987654321098765432109876543210
9322                                                             xxxx1xxxx0xxxx10xxxxx0111x100100
9323                                                             orns.  */
9324                                                          return 1693;
9325                                                        }
9326                                                      else
9327                                                        {
9328                                                          /* 33222222222211111111110000000000
9329                                                             10987654321098765432109876543210
9330                                                             xxxx1xxxx1xxxx10xxxxx0111x100100
9331                                                             nands.  */
9332                                                          return 1687;
9333                                                        }
9334                                                    }
9335                                                }
9336                                              else
9337                                                {
9338                                                  if (((word >> 13) & 0x1) == 0)
9339                                                    {
9340                                                      /* 33222222222211111111110000000000
9341                                                         10987654321098765432109876543210
9342                                                         xxxxxxxxxxxxx010xxxxx0111x100101
9343                                                         ld1sb.  */
9344                                                      return 1517;
9345                                                    }
9346                                                  else
9347                                                    {
9348                                                      /* 33222222222211111111110000000000
9349                                                         10987654321098765432109876543210
9350                                                         xxxxxxxxxxxxx110xxxxx0111x100101
9351                                                         ldff1sb.  */
9352                                                      return 1609;
9353                                                    }
9354                                                }
9355                                            }
9356                                        }
9357                                    }
9358                                  else
9359                                    {
9360                                      if (((word >> 13) & 0x1) == 0)
9361                                        {
9362                                          if (((word >> 22) & 0x1) == 0)
9363                                            {
9364                                              if (((word >> 23) & 0x1) == 0)
9365                                                {
9366                                                  /* 33222222222211111111110000000000
9367                                                     10987654321098765432109876543210
9368                                                     xxxxxxxxxxxxx010xxxxx1001x10010x
9369                                                     ld1sh.  */
9370                                                  return 1528;
9371                                                }
9372                                              else
9373                                                {
9374                                                  /* 33222222222211111111110000000000
9375                                                     10987654321098765432109876543210
9376                                                     xxxxxxxxxxxxx010xxxxx1011x10010x
9377                                                     ld1sb.  */
9378                                                  return 1516;
9379                                                }
9380                                            }
9381                                          else
9382                                            {
9383                                              if (((word >> 23) & 0x1) == 0)
9384                                                {
9385                                                  /* 33222222222211111111110000000000
9386                                                     10987654321098765432109876543210
9387                                                     xxxxxxxxxxxxx010xxxxx1101x10010x
9388                                                     ld1w.  */
9389                                                  return 1547;
9390                                                }
9391                                              else
9392                                                {
9393                                                  /* 33222222222211111111110000000000
9394                                                     10987654321098765432109876543210
9395                                                     xxxxxxxxxxxxx010xxxxx1111x10010x
9396                                                     ld1d.  */
9397                                                  return 1469;
9398                                                }
9399                                            }
9400                                        }
9401                                      else
9402                                        {
9403                                          if (((word >> 22) & 0x1) == 0)
9404                                            {
9405                                              if (((word >> 23) & 0x1) == 0)
9406                                                {
9407                                                  /* 33222222222211111111110000000000
9408                                                     10987654321098765432109876543210
9409                                                     xxxxxxxxxxxxx110xxxxx1001x10010x
9410                                                     ldff1sh.  */
9411                                                  return 1617;
9412                                                }
9413                                              else
9414                                                {
9415                                                  /* 33222222222211111111110000000000
9416                                                     10987654321098765432109876543210
9417                                                     xxxxxxxxxxxxx110xxxxx1011x10010x
9418                                                     ldff1sb.  */
9419                                                  return 1608;
9420                                                }
9421                                            }
9422                                          else
9423                                            {
9424                                              if (((word >> 23) & 0x1) == 0)
9425                                                {
9426                                                  /* 33222222222211111111110000000000
9427                                                     10987654321098765432109876543210
9428                                                     xxxxxxxxxxxxx110xxxxx1101x10010x
9429                                                     ldff1w.  */
9430                                                  return 1633;
9431                                                }
9432                                              else
9433                                                {
9434                                                  /* 33222222222211111111110000000000
9435                                                     10987654321098765432109876543210
9436                                                     xxxxxxxxxxxxx110xxxxx1111x10010x
9437                                                     ldff1d.  */
9438                                                  return 1589;
9439                                                }
9440                                            }
9441                                        }
9442                                    }
9443                                }
9444                              else
9445                                {
9446                                  if (((word >> 13) & 0x1) == 0)
9447                                    {
9448                                      if (((word >> 31) & 0x1) == 0)
9449                                        {
9450                                          if (((word >> 21) & 0x1) == 0)
9451                                            {
9452                                              if (((word >> 4) & 0x1) == 0)
9453                                                {
9454                                                  /* 33222222222211111111110000000000
9455                                                     10987654321098765432109876543210
9456                                                     xxxx0xxxxxxxx010xxxxx0xx1x100110
9457                                                     fcmge.  */
9458                                                  return 1348;
9459                                                }
9460                                              else
9461                                                {
9462                                                  /* 33222222222211111111110000000000
9463                                                     10987654321098765432109876543210
9464                                                     xxxx1xxxxxxxx010xxxxx0xx1x100110
9465                                                     fcmgt.  */
9466                                                  return 1350;
9467                                                }
9468                                            }
9469                                          else
9470                                            {
9471                                              /* 33222222222211111111110000000000
9472                                                 10987654321098765432109876543210
9473                                                 xxxxxxxxxxxxx010xxxxx1xx1x100110
9474                                                 fnmla.  */
9475                                              return 1412;
9476                                            }
9477                                        }
9478                                      else
9479                                        {
9480                                          if (((word >> 22) & 0x1) == 0)
9481                                            {
9482                                              /* 33222222222211111111110000000000
9483                                                 10987654321098765432109876543210
9484                                                 xxxxxxxxxxxxx010xxxxxx0x1x100111
9485                                                 str.  */
9486                                              return 1882;
9487                                            }
9488                                          else
9489                                            {
9490                                              if (((word >> 21) & 0x1) == 0)
9491                                                {
9492                                                  /* 33222222222211111111110000000000
9493                                                     10987654321098765432109876543210
9494                                                     xxxxxxxxxxxxx010xxxxx01x1x100111
9495                                                     st1w.  */
9496                                                  return 1841;
9497                                                }
9498                                              else
9499                                                {
9500                                                  if (((word >> 23) & 0x1) == 0)
9501                                                    {
9502                                                      /* 33222222222211111111110000000000
9503                                                         10987654321098765432109876543210
9504                                                         xxxxxxxxxxxxx010xxxxx1101x100111
9505                                                         st1w.  */
9506                                                      return 1843;
9507                                                    }
9508                                                  else
9509                                                    {
9510                                                      /* 33222222222211111111110000000000
9511                                                         10987654321098765432109876543210
9512                                                         xxxxxxxxxxxxx010xxxxx1111x100111
9513                                                         st1d.  */
9514                                                      return 1820;
9515                                                    }
9516                                                }
9517                                            }
9518                                        }
9519                                    }
9520                                  else
9521                                    {
9522                                      if (((word >> 21) & 0x1) == 0)
9523                                        {
9524                                          if (((word >> 31) & 0x1) == 0)
9525                                            {
9526                                              if (((word >> 4) & 0x1) == 0)
9527                                                {
9528                                                  /* 33222222222211111111110000000000
9529                                                     10987654321098765432109876543210
9530                                                     xxxx0xxxxxxxx110xxxxx0xx1x100110
9531                                                     fcmeq.  */
9532                                                  return 1346;
9533                                                }
9534                                              else
9535                                                {
9536                                                  /* 33222222222211111111110000000000
9537                                                     10987654321098765432109876543210
9538                                                     xxxx1xxxxxxxx110xxxxx0xx1x100110
9539                                                     fcmne.  */
9540                                                  return 1354;
9541                                                }
9542                                            }
9543                                          else
9544                                            {
9545                                              if (((word >> 22) & 0x1) == 0)
9546                                                {
9547                                                  if (((word >> 23) & 0x1) == 0)
9548                                                    {
9549                                                      /* 33222222222211111111110000000000
9550                                                         10987654321098765432109876543210
9551                                                         xxxxxxxxxxxxx110xxxxx0001x100111
9552                                                         stnt1w.  */
9553                                                      return 1879;
9554                                                    }
9555                                                  else
9556                                                    {
9557                                                      /* 33222222222211111111110000000000
9558                                                         10987654321098765432109876543210
9559                                                         xxxxxxxxxxxxx110xxxxx0011x100111
9560                                                         stnt1d.  */
9561                                                      return 1875;
9562                                                    }
9563                                                }
9564                                              else
9565                                                {
9566                                                  if (((word >> 23) & 0x1) == 0)
9567                                                    {
9568                                                      /* 33222222222211111111110000000000
9569                                                         10987654321098765432109876543210
9570                                                         xxxxxxxxxxxxx110xxxxx0101x100111
9571                                                         st3w.  */
9572                                                      return 1863;
9573                                                    }
9574                                                  else
9575                                                    {
9576                                                      /* 33222222222211111111110000000000
9577                                                         10987654321098765432109876543210
9578                                                         xxxxxxxxxxxxx110xxxxx0111x100111
9579                                                         st3d.  */
9580                                                      return 1859;
9581                                                    }
9582                                                }
9583                                            }
9584                                        }
9585                                      else
9586                                        {
9587                                          if (((word >> 31) & 0x1) == 0)
9588                                            {
9589                                              /* 33222222222211111111110000000000
9590                                                 10987654321098765432109876543210
9591                                                 xxxxxxxxxxxxx110xxxxx1xx1x100110
9592                                                 fnmls.  */
9593                                              return 1413;
9594                                            }
9595                                          else
9596                                            {
9597                                              if (((word >> 22) & 0x1) == 0)
9598                                                {
9599                                                  if (((word >> 23) & 0x1) == 0)
9600                                                    {
9601                                                      /* 33222222222211111111110000000000
9602                                                         10987654321098765432109876543210
9603                                                         xxxxxxxxxxxxx110xxxxx1001x100111
9604                                                         st2w.  */
9605                                                      return 1855;
9606                                                    }
9607                                                  else
9608                                                    {
9609                                                      /* 33222222222211111111110000000000
9610                                                         10987654321098765432109876543210
9611                                                         xxxxxxxxxxxxx110xxxxx1011x100111
9612                                                         st2d.  */
9613                                                      return 1851;
9614                                                    }
9615                                                }
9616                                              else
9617                                                {
9618                                                  if (((word >> 23) & 0x1) == 0)
9619                                                    {
9620                                                      /* 33222222222211111111110000000000
9621                                                         10987654321098765432109876543210
9622                                                         xxxxxxxxxxxxx110xxxxx1101x100111
9623                                                         st4w.  */
9624                                                      return 1871;
9625                                                    }
9626                                                  else
9627                                                    {
9628                                                      /* 33222222222211111111110000000000
9629                                                         10987654321098765432109876543210
9630                                                         xxxxxxxxxxxxx110xxxxx1111x100111
9631                                                         st4d.  */
9632                                                      return 1867;
9633                                                    }
9634                                                }
9635                                            }
9636                                        }
9637                                    }
9638                                }
9639                            }
9640                        }
9641                      else
9642                        {
9643                          if (((word >> 21) & 0x1) == 0)
9644                            {
9645                              if (((word >> 30) & 0x1) == 0)
9646                                {
9647                                  if (((word >> 14) & 0x1) == 0)
9648                                    {
9649                                      if (((word >> 13) & 0x1) == 0)
9650                                        {
9651                                          if (((word >> 4) & 0x1) == 0)
9652                                            {
9653                                              /* 33222222222211111111110000000000
9654                                                 10987654321098765432109876543210
9655                                                 xxxx0xxxxxxxx001xxxxx0xx1x10010x
9656                                                 cmpeq.  */
9657                                              return 1275;
9658                                            }
9659                                          else
9660                                            {
9661                                              /* 33222222222211111111110000000000
9662                                                 10987654321098765432109876543210
9663                                                 xxxx1xxxxxxxx001xxxxx0xx1x10010x
9664                                                 cmpne.  */
9665                                              return 1298;
9666                                            }
9667                                        }
9668                                      else
9669                                        {
9670                                          if (((word >> 20) & 0x1) == 0)
9671                                            {
9672                                              if (((word >> 22) & 0x1) == 0)
9673                                                {
9674                                                  if (((word >> 23) & 0x1) == 0)
9675                                                    {
9676                                                      /* 33222222222211111111110000000000
9677                                                         10987654321098765432109876543210
9678                                                         xxxxxxxxxxxxx101xxxx00001x10010x
9679                                                         ld1sh.  */
9680                                                      return 1534;
9681                                                    }
9682                                                  else
9683                                                    {
9684                                                      /* 33222222222211111111110000000000
9685                                                         10987654321098765432109876543210
9686                                                         xxxxxxxxxxxxx101xxxx00011x10010x
9687                                                         ld1sb.  */
9688                                                      return 1521;
9689                                                    }
9690                                                }
9691                                              else
9692                                                {
9693                                                  if (((word >> 23) & 0x1) == 0)
9694                                                    {
9695                                                      /* 33222222222211111111110000000000
9696                                                         10987654321098765432109876543210
9697                                                         xxxxxxxxxxxxx101xxxx00101x10010x
9698                                                         ld1w.  */
9699                                                      return 1553;
9700                                                    }
9701                                                  else
9702                                                    {
9703                                                      /* 33222222222211111111110000000000
9704                                                         10987654321098765432109876543210
9705                                                         xxxxxxxxxxxxx101xxxx00111x10010x
9706                                                         ld1sb.  */
9707                                                      return 1523;
9708                                                    }
9709                                                }
9710                                            }
9711                                          else
9712                                            {
9713                                              if (((word >> 22) & 0x1) == 0)
9714                                                {
9715                                                  if (((word >> 23) & 0x1) == 0)
9716                                                    {
9717                                                      /* 33222222222211111111110000000000
9718                                                         10987654321098765432109876543210
9719                                                         xxxxxxxxxxxxx101xxxx10001x10010x
9720                                                         ldnf1sh.  */
9721                                                      return 1651;
9722                                                    }
9723                                                  else
9724                                                    {
9725                                                      /* 33222222222211111111110000000000
9726                                                         10987654321098765432109876543210
9727                                                         xxxxxxxxxxxxx101xxxx10011x10010x
9728                                                         ldnf1sb.  */
9729                                                      return 1648;
9730                                                    }
9731                                                }
9732                                              else
9733                                                {
9734                                                  if (((word >> 23) & 0x1) == 0)
9735                                                    {
9736                                                      /* 33222222222211111111110000000000
9737                                                         10987654321098765432109876543210
9738                                                         xxxxxxxxxxxxx101xxxx10101x10010x
9739                                                         ldnf1w.  */
9740                                                      return 1654;
9741                                                    }
9742                                                  else
9743                                                    {
9744                                                      /* 33222222222211111111110000000000
9745                                                         10987654321098765432109876543210
9746                                                         xxxxxxxxxxxxx101xxxx10111x10010x
9747                                                         ldnf1sb.  */
9748                                                      return 1650;
9749                                                    }
9750                                                }
9751                                            }
9752                                        }
9753                                    }
9754                                  else
9755                                    {
9756                                      if (((word >> 31) & 0x1) == 0)
9757                                        {
9758                                          if (((word >> 4) & 0x1) == 0)
9759                                            {
9760                                              if (((word >> 20) & 0x1) == 0)
9761                                                {
9762                                                  if (((word >> 22) & 0x1) == 0)
9763                                                    {
9764                                                      /* 33222222222211111111110000000000
9765                                                         10987654321098765432109876543210
9766                                                         xxxx0xxxxxxxxx11xxxx000x1x100100
9767                                                         brkpa.  */
9768                                                      return 1261;
9769                                                    }
9770                                                  else
9771                                                    {
9772                                                      /* 33222222222211111111110000000000
9773                                                         10987654321098765432109876543210
9774                                                         xxxx0xxxxxxxxx11xxxx001x1x100100
9775                                                         brkpas.  */
9776                                                      return 1262;
9777                                                    }
9778                                                }
9779                                              else
9780                                                {
9781                                                  if (((word >> 16) & 0x1) == 0)
9782                                                    {
9783                                                      if (((word >> 19) & 0x1) == 0)
9784                                                        {
9785                                                          /* 33222222222211111111110000000000
9786                                                             10987654321098765432109876543210
9787                                                             xxxx0xxxxxxxxx110xx010xx1x100100
9788                                                             ptest.  */
9789                                                          return 1731;
9790                                                        }
9791                                                      else
9792                                                        {
9793                                                          if (((word >> 10) & 0x1) == 0)
9794                                                            {
9795                                                              if (((word >> 12) & 0x1) == 0)
9796                                                                {
9797                                                                  if (((word >> 13) & 0x1) == 0)
9798                                                                    {
9799                                                                      /* 33222222222211111111110000000000
9800                                                                         10987654321098765432109876543210
9801                                                                         xxxx0xxxxx0x00110xx110xx1x100100
9802                                                                         pfirst.  */
9803                                                                      return 1701;
9804                                                                    }
9805                                                                  else
9806                                                                    {
9807                                                                      /* 33222222222211111111110000000000
9808                                                                         10987654321098765432109876543210
9809                                                                         xxxx0xxxxx0x01110xx110xx1x100100
9810                                                                         ptrue.  */
9811                                                                      return 1732;
9812                                                                    }
9813                                                                }
9814                                                              else
9815                                                                {
9816                                                                  if (((word >> 22) & 0x1) == 0)
9817                                                                    {
9818                                                                      /* 33222222222211111111110000000000
9819                                                                         10987654321098765432109876543210
9820                                                                         xxxx0xxxxx0x1x110xx1100x1x100100
9821                                                                         rdffr.  */
9822                                                                      return 1738;
9823                                                                    }
9824                                                                  else
9825                                                                    {
9826                                                                      /* 33222222222211111111110000000000
9827                                                                         10987654321098765432109876543210
9828                                                                         xxxx0xxxxx0x1x110xx1101x1x100100
9829                                                                         rdffrs.  */
9830                                                                      return 1739;
9831                                                                    }
9832                                                                }
9833                                                            }
9834                                                          else
9835                                                            {
9836                                                              /* 33222222222211111111110000000000
9837                                                                 10987654321098765432109876543210
9838                                                                 xxxx0xxxxx1xxx110xx110xx1x100100
9839                                                                 pfalse.  */
9840                                                              return 1700;
9841                                                            }
9842                                                        }
9843                                                    }
9844                                                  else
9845                                                    {
9846                                                      if (((word >> 10) & 0x1) == 0)
9847                                                        {
9848                                                          if (((word >> 12) & 0x1) == 0)
9849                                                            {
9850                                                              /* 33222222222211111111110000000000
9851                                                                 10987654321098765432109876543210
9852                                                                 xxxx0xxxxx0x0x111xxx10xx1x100100
9853                                                                 ptrues.  */
9854                                                              return 1733;
9855                                                            }
9856                                                          else
9857                                                            {
9858                                                              /* 33222222222211111111110000000000
9859                                                                 10987654321098765432109876543210
9860                                                                 xxxx0xxxxx0x1x111xxx10xx1x100100
9861                                                                 rdffr.  */
9862                                                              return 1737;
9863                                                            }
9864                                                        }
9865                                                      else
9866                                                        {
9867                                                          /* 33222222222211111111110000000000
9868                                                             10987654321098765432109876543210
9869                                                             xxxx0xxxxx1xxx111xxx10xx1x100100
9870                                                             pnext.  */
9871                                                          return 1702;
9872                                                        }
9873                                                    }
9874                                                }
9875                                            }
9876                                          else
9877                                            {
9878                                              if (((word >> 22) & 0x1) == 0)
9879                                                {
9880                                                  /* 33222222222211111111110000000000
9881                                                     10987654321098765432109876543210
9882                                                     xxxx1xxxxxxxxx11xxxxx00x1x100100
9883                                                     brkpb.  */
9884                                                  return 1263;
9885                                                }
9886                                              else
9887                                                {
9888                                                  /* 33222222222211111111110000000000
9889                                                     10987654321098765432109876543210
9890                                                     xxxx1xxxxxxxxx11xxxxx01x1x100100
9891                                                     brkpbs.  */
9892                                                  return 1264;
9893                                                }
9894                                            }
9895                                        }
9896                                      else
9897                                        {
9898                                          if (((word >> 13) & 0x1) == 0)
9899                                            {
9900                                              if (((word >> 22) & 0x1) == 0)
9901                                                {
9902                                                  if (((word >> 23) & 0x1) == 0)
9903                                                    {
9904                                                      /* 33222222222211111111110000000000
9905                                                         10987654321098765432109876543210
9906                                                         xxxxxxxxxxxxx011xxxxx0001x100101
9907                                                         ldnt1w.  */
9908                                                      return 1662;
9909                                                    }
9910                                                  else
9911                                                    {
9912                                                      /* 33222222222211111111110000000000
9913                                                         10987654321098765432109876543210
9914                                                         xxxxxxxxxxxxx011xxxxx0011x100101
9915                                                         ldnt1d.  */
9916                                                      return 1658;
9917                                                    }
9918                                                }
9919                                              else
9920                                                {
9921                                                  if (((word >> 23) & 0x1) == 0)
9922                                                    {
9923                                                      /* 33222222222211111111110000000000
9924                                                         10987654321098765432109876543210
9925                                                         xxxxxxxxxxxxx011xxxxx0101x100101
9926                                                         ld3w.  */
9927                                                      return 1570;
9928                                                    }
9929                                                  else
9930                                                    {
9931                                                      /* 33222222222211111111110000000000
9932                                                         10987654321098765432109876543210
9933                                                         xxxxxxxxxxxxx011xxxxx0111x100101
9934                                                         ld3d.  */
9935                                                      return 1566;
9936                                                    }
9937                                                }
9938                                            }
9939                                          else
9940                                            {
9941                                              if (((word >> 22) & 0x1) == 0)
9942                                                {
9943                                                  if (((word >> 23) & 0x1) == 0)
9944                                                    {
9945                                                      /* 33222222222211111111110000000000
9946                                                         10987654321098765432109876543210
9947                                                         xxxxxxxxxxxxx111xxxxx0001x100101
9948                                                         ldnt1w.  */
9949                                                      return 1663;
9950                                                    }
9951                                                  else
9952                                                    {
9953                                                      /* 33222222222211111111110000000000
9954                                                         10987654321098765432109876543210
9955                                                         xxxxxxxxxxxxx111xxxxx0011x100101
9956                                                         ldnt1d.  */
9957                                                      return 1659;
9958                                                    }
9959                                                }
9960                                              else
9961                                                {
9962                                                  if (((word >> 23) & 0x1) == 0)
9963                                                    {
9964                                                      /* 33222222222211111111110000000000
9965                                                         10987654321098765432109876543210
9966                                                         xxxxxxxxxxxxx111xxxxx0101x100101
9967                                                         ld3w.  */
9968                                                      return 1571;
9969                                                    }
9970                                                  else
9971                                                    {
9972                                                      /* 33222222222211111111110000000000
9973                                                         10987654321098765432109876543210
9974                                                         xxxxxxxxxxxxx111xxxxx0111x100101
9975                                                         ld3d.  */
9976                                                      return 1567;
9977                                                    }
9978                                                }
9979                                            }
9980                                        }
9981                                    }
9982                                }
9983                              else
9984                                {
9985                                  if (((word >> 13) & 0x1) == 0)
9986                                    {
9987                                      if (((word >> 31) & 0x1) == 0)
9988                                        {
9989                                          if (((word >> 14) & 0x1) == 0)
9990                                            {
9991                                              if (((word >> 19) & 0x1) == 0)
9992                                                {
9993                                                  if (((word >> 20) & 0x1) == 0)
9994                                                    {
9995                                                      if (((word >> 16) & 0x1) == 0)
9996                                                        {
9997                                                          if (((word >> 17) & 0x1) == 0)
9998                                                            {
9999                                                              if (((word >> 18) & 0x1) == 0)
10000                                                                {
10001                                                                  /* 33222222222211111111110000000000
10002                                                                     10987654321098765432109876543210
10003                                                                     xxxxxxxxxxxxx001000000xx1x100110
10004                                                                     fadd.  */
10005                                                                  return 1337;
10006                                                                }
10007                                                              else
10008                                                                {
10009                                                                  /* 33222222222211111111110000000000
10010                                                                     10987654321098765432109876543210
10011                                                                     xxxxxxxxxxxxx001001000xx1x100110
10012                                                                     fmaxnm.  */
10013                                                                  return 1384;
10014                                                                }
10015                                                            }
10016                                                          else
10017                                                            {
10018                                                              if (((word >> 18) & 0x1) == 0)
10019                                                                {
10020                                                                  /* 33222222222211111111110000000000
10021                                                                     10987654321098765432109876543210
10022                                                                     xxxxxxxxxxxxx001010000xx1x100110
10023                                                                     fmul.  */
10024                                                                  return 1404;
10025                                                                }
10026                                                              else
10027                                                                {
10028                                                                  /* 33222222222211111111110000000000
10029                                                                     10987654321098765432109876543210
10030                                                                     xxxxxxxxxxxxx001011000xx1x100110
10031                                                                     fmax.  */
10032                                                                  return 1382;
10033                                                                }
10034                                                            }
10035                                                        }
10036                                                      else
10037                                                        {
10038                                                          if (((word >> 17) & 0x1) == 0)
10039                                                            {
10040                                                              if (((word >> 18) & 0x1) == 0)
10041                                                                {
10042                                                                  /* 33222222222211111111110000000000
10043                                                                     10987654321098765432109876543210
10044                                                                     xxxxxxxxxxxxx001100000xx1x100110
10045                                                                     fsub.  */
10046                                                                  return 1430;
10047                                                                }
10048                                                              else
10049                                                                {
10050                                                                  /* 33222222222211111111110000000000
10051                                                                     10987654321098765432109876543210
10052                                                                     xxxxxxxxxxxxx001101000xx1x100110
10053                                                                     fminnm.  */
10054                                                                  return 1390;
10055                                                                }
10056                                                            }
10057                                                          else
10058                                                            {
10059                                                              if (((word >> 18) & 0x1) == 0)
10060                                                                {
10061                                                                  /* 33222222222211111111110000000000
10062                                                                     10987654321098765432109876543210
10063                                                                     xxxxxxxxxxxxx001110000xx1x100110
10064                                                                     fsubr.  */
10065                                                                  return 1432;
10066                                                                }
10067                                                              else
10068                                                                {
10069                                                                  /* 33222222222211111111110000000000
10070                                                                     10987654321098765432109876543210
10071                                                                     xxxxxxxxxxxxx001111000xx1x100110
10072                                                                     fmin.  */
10073                                                                  return 1388;
10074                                                                }
10075                                                            }
10076                                                        }
10077                                                    }
10078                                                  else
10079                                                    {
10080                                                      /* 33222222222211111111110000000000
10081                                                         10987654321098765432109876543210
10082                                                         xxxxxxxxxxxxx001xxx010xx1x100110
10083                                                         ftmad.  */
10084                                                      return 1434;
10085                                                    }
10086                                                }
10087                                              else
10088                                                {
10089                                                  if (((word >> 16) & 0x1) == 0)
10090                                                    {
10091                                                      if (((word >> 17) & 0x1) == 0)
10092                                                        {
10093                                                          if (((word >> 18) & 0x1) == 0)
10094                                                            {
10095                                                              if (((word >> 20) & 0x1) == 0)
10096                                                                {
10097                                                                  /* 33222222222211111111110000000000
10098                                                                     10987654321098765432109876543210
10099                                                                     xxxxxxxxxxxxx001000100xx1x100110
10100                                                                     fabd.  */
10101                                                                  return 1332;
10102                                                                }
10103                                                              else
10104                                                                {
10105                                                                  /* 33222222222211111111110000000000
10106                                                                     10987654321098765432109876543210
10107                                                                     xxxxxxxxxxxxx001000110xx1x100110
10108                                                                     fadd.  */
10109                                                                  return 1338;
10110                                                                }
10111                                                            }
10112                                                          else
10113                                                            {
10114                                                              if (((word >> 20) & 0x1) == 0)
10115                                                                {
10116                                                                  /* 33222222222211111111110000000000
10117                                                                     10987654321098765432109876543210
10118                                                                     xxxxxxxxxxxxx001001100xx1x100110
10119                                                                     fdivr.  */
10120                                                                  return 1378;
10121                                                                }
10122                                                              else
10123                                                                {
10124                                                                  /* 33222222222211111111110000000000
10125                                                                     10987654321098765432109876543210
10126                                                                     xxxxxxxxxxxxx001001110xx1x100110
10127                                                                     fmaxnm.  */
10128                                                                  return 1385;
10129                                                                }
10130                                                            }
10131                                                        }
10132                                                      else
10133                                                        {
10134                                                          if (((word >> 18) & 0x1) == 0)
10135                                                            {
10136                                                              if (((word >> 20) & 0x1) == 0)
10137                                                                {
10138                                                                  /* 33222222222211111111110000000000
10139                                                                     10987654321098765432109876543210
10140                                                                     xxxxxxxxxxxxx001010100xx1x100110
10141                                                                     fmulx.  */
10142                                                                  return 1409;
10143                                                                }
10144                                                              else
10145                                                                {
10146                                                                  /* 33222222222211111111110000000000
10147                                                                     10987654321098765432109876543210
10148                                                                     xxxxxxxxxxxxx001010110xx1x100110
10149                                                                     fmul.  */
10150                                                                  return 1405;
10151                                                                }
10152                                                            }
10153                                                          else
10154                                                            {
10155                                                              /* 33222222222211111111110000000000
10156                                                                 10987654321098765432109876543210
10157                                                                 xxxxxxxxxxxxx0010111x0xx1x100110
10158                                                                 fmax.  */
10159                                                              return 1383;
10160                                                            }
10161                                                        }
10162                                                    }
10163                                                  else
10164                                                    {
10165                                                      if (((word >> 17) & 0x1) == 0)
10166                                                        {
10167                                                          if (((word >> 18) & 0x1) == 0)
10168                                                            {
10169                                                              if (((word >> 20) & 0x1) == 0)
10170                                                                {
10171                                                                  /* 33222222222211111111110000000000
10172                                                                     10987654321098765432109876543210
10173                                                                     xxxxxxxxxxxxx001100100xx1x100110
10174                                                                     fscale.  */
10175                                                                  return 1427;
10176                                                                }
10177                                                              else
10178                                                                {
10179                                                                  /* 33222222222211111111110000000000
10180                                                                     10987654321098765432109876543210
10181                                                                     xxxxxxxxxxxxx001100110xx1x100110
10182                                                                     fsub.  */
10183                                                                  return 1431;
10184                                                                }
10185                                                            }
10186                                                          else
10187                                                            {
10188                                                              if (((word >> 20) & 0x1) == 0)
10189                                                                {
10190                                                                  /* 33222222222211111111110000000000
10191                                                                     10987654321098765432109876543210
10192                                                                     xxxxxxxxxxxxx001101100xx1x100110
10193                                                                     fdiv.  */
10194                                                                  return 1377;
10195                                                                }
10196                                                              else
10197                                                                {
10198                                                                  /* 33222222222211111111110000000000
10199                                                                     10987654321098765432109876543210
10200                                                                     xxxxxxxxxxxxx001101110xx1x100110
10201                                                                     fminnm.  */
10202                                                                  return 1391;
10203                                                                }
10204                                                            }
10205                                                        }
10206                                                      else
10207                                                        {
10208                                                          if (((word >> 18) & 0x1) == 0)
10209                                                            {
10210                                                              /* 33222222222211111111110000000000
10211                                                                 10987654321098765432109876543210
10212                                                                 xxxxxxxxxxxxx0011101x0xx1x100110
10213                                                                 fsubr.  */
10214                                                              return 1433;
10215                                                            }
10216                                                          else
10217                                                            {
10218                                                              /* 33222222222211111111110000000000
10219                                                                 10987654321098765432109876543210
10220                                                                 xxxxxxxxxxxxx0011111x0xx1x100110
10221                                                                 fmin.  */
10222                                                              return 1389;
10223                                                            }
10224                                                        }
10225                                                    }
10226                                                }
10227                                            }
10228                                          else
10229                                            {
10230                                              if (((word >> 4) & 0x1) == 0)
10231                                                {
10232                                                  /* 33222222222211111111110000000000
10233                                                     10987654321098765432109876543210
10234                                                     xxxx0xxxxxxxx011xxxxx0xx1x100110
10235                                                     fcmuo.  */
10236                                                  return 1355;
10237                                                }
10238                                              else
10239                                                {
10240                                                  /* 33222222222211111111110000000000
10241                                                     10987654321098765432109876543210
10242                                                     xxxx1xxxxxxxx011xxxxx0xx1x100110
10243                                                     facge.  */
10244                                                  return 1334;
10245                                                }
10246                                            }
10247                                        }
10248                                      else
10249                                        {
10250                                          if (((word >> 22) & 0x1) == 0)
10251                                            {
10252                                              if (((word >> 23) & 0x1) == 0)
10253                                                {
10254                                                  /* 33222222222211111111110000000000
10255                                                     10987654321098765432109876543210
10256                                                     xxxxxxxxxxxxx0x1xxxxx0001x100111
10257                                                     st1w.  */
10258                                                  return 1837;
10259                                                }
10260                                              else
10261                                                {
10262                                                  /* 33222222222211111111110000000000
10263                                                     10987654321098765432109876543210
10264                                                     xxxxxxxxxxxxx0x1xxxxx0011x100111
10265                                                     st1d.  */
10266                                                  return 1816;
10267                                                }
10268                                            }
10269                                          else
10270                                            {
10271                                              /* 33222222222211111111110000000000
10272                                                 10987654321098765432109876543210
10273                                                 xxxxxxxxxxxxx0x1xxxxx01x1x100111
10274                                                 st1w.  */
10275                                              return 1842;
10276                                            }
10277                                        }
10278                                    }
10279                                  else
10280                                    {
10281                                      if (((word >> 14) & 0x1) == 0)
10282                                        {
10283                                          if (((word >> 31) & 0x1) == 0)
10284                                            {
10285                                              if (((word >> 16) & 0x1) == 0)
10286                                                {
10287                                                  if (((word >> 17) & 0x1) == 0)
10288                                                    {
10289                                                      if (((word >> 18) & 0x1) == 0)
10290                                                        {
10291                                                          if (((word >> 19) & 0x1) == 0)
10292                                                            {
10293                                                              if (((word >> 20) & 0x1) == 0)
10294                                                                {
10295                                                                  /* 33222222222211111111110000000000
10296                                                                     10987654321098765432109876543210
10297                                                                     xxxxxxxxxxxxx101000000xx1x100110
10298                                                                     frintn.  */
10299                                                                  return 1421;
10300                                                                }
10301                                                              else
10302                                                                {
10303                                                                  /* 33222222222211111111110000000000
10304                                                                     10987654321098765432109876543210
10305                                                                     xxxxxxxxxxxxx101000010xx1x100110
10306                                                                     scvtf.  */
10307                                                                  return 1751;
10308                                                                }
10309                                                            }
10310                                                          else
10311                                                            {
10312                                                              if (((word >> 20) & 0x1) == 0)
10313                                                                {
10314                                                                  if (((word >> 22) & 0x1) == 0)
10315                                                                    {
10316                                                                      /* 33222222222211111111110000000000
10317                                                                         10987654321098765432109876543210
10318                                                                         xxxxxxxxxxxxx1010001000x1x100110
10319                                                                         fcvt.  */
10320                                                                      return 1357;
10321                                                                    }
10322                                                                  else
10323                                                                    {
10324                                                                      /* 33222222222211111111110000000000
10325                                                                         10987654321098765432109876543210
10326                                                                         xxxxxxxxxxxxx1010001001x1x100110
10327                                                                         fcvt.  */
10328                                                                      return 1359;
10329                                                                    }
10330                                                                }
10331                                                              else
10332                                                                {
10333                                                                  /* 33222222222211111111110000000000
10334                                                                     10987654321098765432109876543210
10335                                                                     xxxxxxxxxxxxx101000110xx1x100110
10336                                                                     fcvtzs.  */
10337                                                                  return 1367;
10338                                                                }
10339                                                            }
10340                                                        }
10341                                                      else
10342                                                        {
10343                                                          if (((word >> 19) & 0x1) == 0)
10344                                                            {
10345                                                              if (((word >> 20) & 0x1) == 0)
10346                                                                {
10347                                                                  /* 33222222222211111111110000000000
10348                                                                     10987654321098765432109876543210
10349                                                                     xxxxxxxxxxxxx101001000xx1x100110
10350                                                                     frinta.  */
10351                                                                  return 1418;
10352                                                                }
10353                                                              else
10354                                                                {
10355                                                                  if (((word >> 22) & 0x1) == 0)
10356                                                                    {
10357                                                                      /* 33222222222211111111110000000000
10358                                                                         10987654321098765432109876543210
10359                                                                         xxxxxxxxxxxxx1010010100x1x100110
10360                                                                         scvtf.  */
10361                                                                      return 1750;
10362                                                                    }
10363                                                                  else
10364                                                                    {
10365                                                                      if (((word >> 23) & 0x1) == 0)
10366                                                                        {
10367                                                                          /* 33222222222211111111110000000000
10368                                                                             10987654321098765432109876543210
10369                                                                             xxxxxxxxxxxxx101001010101x100110
10370                                                                             scvtf.  */
10371                                                                          return 1749;
10372                                                                        }
10373                                                                      else
10374                                                                        {
10375                                                                          /* 33222222222211111111110000000000
10376                                                                             10987654321098765432109876543210
10377                                                                             xxxxxxxxxxxxx101001010111x100110
10378                                                                             scvtf.  */
10379                                                                          return 1753;
10380                                                                        }
10381                                                                    }
10382                                                                }
10383                                                            }
10384                                                          else
10385                                                            {
10386                                                              if (((word >> 20) & 0x1) == 0)
10387                                                                {
10388                                                                  /* 33222222222211111111110000000000
10389                                                                     10987654321098765432109876543210
10390                                                                     xxxxxxxxxxxxx101001100xx1x100110
10391                                                                     frecpx.  */
10392                                                                  return 1417;
10393                                                                }
10394                                                              else
10395                                                                {
10396                                                                  if (((word >> 22) & 0x1) == 0)
10397                                                                    {
10398                                                                      /* 33222222222211111111110000000000
10399                                                                         10987654321098765432109876543210
10400                                                                         xxxxxxxxxxxxx1010011100x1x100110
10401                                                                         fcvtzs.  */
10402                                                                      return 1366;
10403                                                                    }
10404                                                                  else
10405                                                                    {
10406                                                                      if (((word >> 23) & 0x1) == 0)
10407                                                                        {
10408                                                                          /* 33222222222211111111110000000000
10409                                                                             10987654321098765432109876543210
10410                                                                             xxxxxxxxxxxxx101001110101x100110
10411                                                                             fcvtzs.  */
10412                                                                          return 1364;
10413                                                                        }
10414                                                                      else
10415                                                                        {
10416                                                                          /* 33222222222211111111110000000000
10417                                                                             10987654321098765432109876543210
10418                                                                             xxxxxxxxxxxxx101001110111x100110
10419                                                                             fcvtzs.  */
10420                                                                          return 1368;
10421                                                                        }
10422                                                                    }
10423                                                                }
10424                                                            }
10425                                                        }
10426                                                    }
10427                                                  else
10428                                                    {
10429                                                      if (((word >> 18) & 0x1) == 0)
10430                                                        {
10431                                                          if (((word >> 19) & 0x1) == 0)
10432                                                            {
10433                                                              if (((word >> 20) & 0x1) == 0)
10434                                                                {
10435                                                                  /* 33222222222211111111110000000000
10436                                                                     10987654321098765432109876543210
10437                                                                     xxxxxxxxxxxxx101010000xx1x100110
10438                                                                     frintm.  */
10439                                                                  return 1420;
10440                                                                }
10441                                                              else
10442                                                                {
10443                                                                  /* 33222222222211111111110000000000
10444                                                                     10987654321098765432109876543210
10445                                                                     xxxxxxxxxxxxx101010010xx1x100110
10446                                                                     scvtf.  */
10447                                                                  return 1748;
10448                                                                }
10449                                                            }
10450                                                          else
10451                                                            {
10452                                                              if (((word >> 20) & 0x1) == 0)
10453                                                                {
10454                                                                  /* 33222222222211111111110000000000
10455                                                                     10987654321098765432109876543210
10456                                                                     xxxxxxxxxxxxx101010100xx1x100110
10457                                                                     fcvt.  */
10458                                                                  return 1361;
10459                                                                }
10460                                                              else
10461                                                                {
10462                                                                  /* 33222222222211111111110000000000
10463                                                                     10987654321098765432109876543210
10464                                                                     xxxxxxxxxxxxx101010110xx1x100110
10465                                                                     fcvtzs.  */
10466                                                                  return 1363;
10467                                                                }
10468                                                            }
10469                                                        }
10470                                                      else
10471                                                        {
10472                                                          if (((word >> 19) & 0x1) == 0)
10473                                                            {
10474                                                              if (((word >> 20) & 0x1) == 0)
10475                                                                {
10476                                                                  /* 33222222222211111111110000000000
10477                                                                     10987654321098765432109876543210
10478                                                                     xxxxxxxxxxxxx101011000xx1x100110
10479                                                                     frintx.  */
10480                                                                  return 1423;
10481                                                                }
10482                                                              else
10483                                                                {
10484                                                                  if (((word >> 23) & 0x1) == 0)
10485                                                                    {
10486                                                                      /* 33222222222211111111110000000000
10487                                                                         10987654321098765432109876543210
10488                                                                         xxxxxxxxxxxxx101011010x01x100110
10489                                                                         scvtf.  */
10490                                                                      return 1752;
10491                                                                    }
10492                                                                  else
10493                                                                    {
10494                                                                      /* 33222222222211111111110000000000
10495                                                                         10987654321098765432109876543210
10496                                                                         xxxxxxxxxxxxx101011010x11x100110
10497                                                                         scvtf.  */
10498                                                                      return 1754;
10499                                                                    }
10500                                                                }
10501                                                            }
10502                                                          else
10503                                                            {
10504                                                              if (((word >> 23) & 0x1) == 0)
10505                                                                {
10506                                                                  /* 33222222222211111111110000000000
10507                                                                     10987654321098765432109876543210
10508                                                                     xxxxxxxxxxxxx1010111x0x01x100110
10509                                                                     fcvtzs.  */
10510                                                                  return 1365;
10511                                                                }
10512                                                              else
10513                                                                {
10514                                                                  /* 33222222222211111111110000000000
10515                                                                     10987654321098765432109876543210
10516                                                                     xxxxxxxxxxxxx1010111x0x11x100110
10517                                                                     fcvtzs.  */
10518                                                                  return 1369;
10519                                                                }
10520                                                            }
10521                                                        }
10522                                                    }
10523                                                }
10524                                              else
10525                                                {
10526                                                  if (((word >> 17) & 0x1) == 0)
10527                                                    {
10528                                                      if (((word >> 18) & 0x1) == 0)
10529                                                        {
10530                                                          if (((word >> 19) & 0x1) == 0)
10531                                                            {
10532                                                              if (((word >> 20) & 0x1) == 0)
10533                                                                {
10534                                                                  /* 33222222222211111111110000000000
10535                                                                     10987654321098765432109876543210
10536                                                                     xxxxxxxxxxxxx101100000xx1x100110
10537                                                                     frintp.  */
10538                                                                  return 1422;
10539                                                                }
10540                                                              else
10541                                                                {
10542                                                                  /* 33222222222211111111110000000000
10543                                                                     10987654321098765432109876543210
10544                                                                     xxxxxxxxxxxxx101100010xx1x100110
10545                                                                     ucvtf.  */
10546                                                                  return 1903;
10547                                                                }
10548                                                            }
10549                                                          else
10550                                                            {
10551                                                              if (((word >> 20) & 0x1) == 0)
10552                                                                {
10553                                                                  if (((word >> 22) & 0x1) == 0)
10554                                                                    {
10555                                                                      /* 33222222222211111111110000000000
10556                                                                         10987654321098765432109876543210
10557                                                                         xxxxxxxxxxxxx1011001000x1x100110
10558                                                                         fcvt.  */
10559                                                                      return 1358;
10560                                                                    }
10561                                                                  else
10562                                                                    {
10563                                                                      /* 33222222222211111111110000000000
10564                                                                         10987654321098765432109876543210
10565                                                                         xxxxxxxxxxxxx1011001001x1x100110
10566                                                                         fcvt.  */
10567                                                                      return 1360;
10568                                                                    }
10569                                                                }
10570                                                              else
10571                                                                {
10572                                                                  /* 33222222222211111111110000000000
10573                                                                     10987654321098765432109876543210
10574                                                                     xxxxxxxxxxxxx101100110xx1x100110
10575                                                                     fcvtzu.  */
10576                                                                  return 1374;
10577                                                                }
10578                                                            }
10579                                                        }
10580                                                      else
10581                                                        {
10582                                                          if (((word >> 19) & 0x1) == 0)
10583                                                            {
10584                                                              if (((word >> 22) & 0x1) == 0)
10585                                                                {
10586                                                                  /* 33222222222211111111110000000000
10587                                                                     10987654321098765432109876543210
10588                                                                     xxxxxxxxxxxxx1011010x00x1x100110
10589                                                                     ucvtf.  */
10590                                                                  return 1902;
10591                                                                }
10592                                                              else
10593                                                                {
10594                                                                  if (((word >> 23) & 0x1) == 0)
10595                                                                    {
10596                                                                      /* 33222222222211111111110000000000
10597                                                                         10987654321098765432109876543210
10598                                                                         xxxxxxxxxxxxx1011010x0101x100110
10599                                                                         ucvtf.  */
10600                                                                      return 1901;
10601                                                                    }
10602                                                                  else
10603                                                                    {
10604                                                                      /* 33222222222211111111110000000000
10605                                                                         10987654321098765432109876543210
10606                                                                         xxxxxxxxxxxxx1011010x0111x100110
10607                                                                         ucvtf.  */
10608                                                                      return 1905;
10609                                                                    }
10610                                                                }
10611                                                            }
10612                                                          else
10613                                                            {
10614                                                              if (((word >> 20) & 0x1) == 0)
10615                                                                {
10616                                                                  /* 33222222222211111111110000000000
10617                                                                     10987654321098765432109876543210
10618                                                                     xxxxxxxxxxxxx101101100xx1x100110
10619                                                                     fsqrt.  */
10620                                                                  return 1428;
10621                                                                }
10622                                                              else
10623                                                                {
10624                                                                  if (((word >> 22) & 0x1) == 0)
10625                                                                    {
10626                                                                      /* 33222222222211111111110000000000
10627                                                                         10987654321098765432109876543210
10628                                                                         xxxxxxxxxxxxx1011011100x1x100110
10629                                                                         fcvtzu.  */
10630                                                                      return 1373;
10631                                                                    }
10632                                                                  else
10633                                                                    {
10634                                                                      if (((word >> 23) & 0x1) == 0)
10635                                                                        {
10636                                                                          /* 33222222222211111111110000000000
10637                                                                             10987654321098765432109876543210
10638                                                                             xxxxxxxxxxxxx101101110101x100110
10639                                                                             fcvtzu.  */
10640                                                                          return 1371;
10641                                                                        }
10642                                                                      else
10643                                                                        {
10644                                                                          /* 33222222222211111111110000000000
10645                                                                             10987654321098765432109876543210
10646                                                                             xxxxxxxxxxxxx101101110111x100110
10647                                                                             fcvtzu.  */
10648                                                                          return 1375;
10649                                                                        }
10650                                                                    }
10651                                                                }
10652                                                            }
10653                                                        }
10654                                                    }
10655                                                  else
10656                                                    {
10657                                                      if (((word >> 18) & 0x1) == 0)
10658                                                        {
10659                                                          if (((word >> 19) & 0x1) == 0)
10660                                                            {
10661                                                              if (((word >> 20) & 0x1) == 0)
10662                                                                {
10663                                                                  /* 33222222222211111111110000000000
10664                                                                     10987654321098765432109876543210
10665                                                                     xxxxxxxxxxxxx101110000xx1x100110
10666                                                                     frintz.  */
10667                                                                  return 1424;
10668                                                                }
10669                                                              else
10670                                                                {
10671                                                                  /* 33222222222211111111110000000000
10672                                                                     10987654321098765432109876543210
10673                                                                     xxxxxxxxxxxxx101110010xx1x100110
10674                                                                     ucvtf.  */
10675                                                                  return 1900;
10676                                                                }
10677                                                            }
10678                                                          else
10679                                                            {
10680                                                              if (((word >> 20) & 0x1) == 0)
10681                                                                {
10682                                                                  /* 33222222222211111111110000000000
10683                                                                     10987654321098765432109876543210
10684                                                                     xxxxxxxxxxxxx101110100xx1x100110
10685                                                                     fcvt.  */
10686                                                                  return 1362;
10687                                                                }
10688                                                              else
10689                                                                {
10690                                                                  /* 33222222222211111111110000000000
10691                                                                     10987654321098765432109876543210
10692                                                                     xxxxxxxxxxxxx101110110xx1x100110
10693                                                                     fcvtzu.  */
10694                                                                  return 1370;
10695                                                                }
10696                                                            }
10697                                                        }
10698                                                      else
10699                                                        {
10700                                                          if (((word >> 19) & 0x1) == 0)
10701                                                            {
10702                                                              if (((word >> 20) & 0x1) == 0)
10703                                                                {
10704                                                                  /* 33222222222211111111110000000000
10705                                                                     10987654321098765432109876543210
10706                                                                     xxxxxxxxxxxxx101111000xx1x100110
10707                                                                     frinti.  */
10708                                                                  return 1419;
10709                                                                }
10710                                                              else
10711                                                                {
10712                                                                  if (((word >> 23) & 0x1) == 0)
10713                                                                    {
10714                                                                      /* 33222222222211111111110000000000
10715                                                                         10987654321098765432109876543210
10716                                                                         xxxxxxxxxxxxx101111010x01x100110
10717                                                                         ucvtf.  */
10718                                                                      return 1904;
10719                                                                    }
10720                                                                  else
10721                                                                    {
10722                                                                      /* 33222222222211111111110000000000
10723                                                                         10987654321098765432109876543210
10724                                                                         xxxxxxxxxxxxx101111010x11x100110
10725                                                                         ucvtf.  */
10726                                                                      return 1906;
10727                                                                    }
10728                                                                }
10729                                                            }
10730                                                          else
10731                                                            {
10732                                                              if (((word >> 23) & 0x1) == 0)
10733                                                                {
10734                                                                  /* 33222222222211111111110000000000
10735                                                                     10987654321098765432109876543210
10736                                                                     xxxxxxxxxxxxx1011111x0x01x100110
10737                                                                     fcvtzu.  */
10738                                                                  return 1372;
10739                                                                }
10740                                                              else
10741                                                                {
10742                                                                  /* 33222222222211111111110000000000
10743                                                                     10987654321098765432109876543210
10744                                                                     xxxxxxxxxxxxx1011111x0x11x100110
10745                                                                     fcvtzu.  */
10746                                                                  return 1376;
10747                                                                }
10748                                                            }
10749                                                        }
10750                                                    }
10751                                                }
10752                                            }
10753                                          else
10754                                            {
10755                                              if (((word >> 22) & 0x1) == 0)
10756                                                {
10757                                                  if (((word >> 23) & 0x1) == 0)
10758                                                    {
10759                                                      /* 33222222222211111111110000000000
10760                                                         10987654321098765432109876543210
10761                                                         xxxxxxxxxxxxx101xxxxx0001x100111
10762                                                         st1w.  */
10763                                                      return 1838;
10764                                                    }
10765                                                  else
10766                                                    {
10767                                                      /* 33222222222211111111110000000000
10768                                                         10987654321098765432109876543210
10769                                                         xxxxxxxxxxxxx101xxxxx0011x100111
10770                                                         st1d.  */
10771                                                      return 1817;
10772                                                    }
10773                                                }
10774                                              else
10775                                                {
10776                                                  if (((word >> 23) & 0x1) == 0)
10777                                                    {
10778                                                      /* 33222222222211111111110000000000
10779                                                         10987654321098765432109876543210
10780                                                         xxxxxxxxxxxxx101xxxxx0101x100111
10781                                                         st1w.  */
10782                                                      return 1845;
10783                                                    }
10784                                                  else
10785                                                    {
10786                                                      /* 33222222222211111111110000000000
10787                                                         10987654321098765432109876543210
10788                                                         xxxxxxxxxxxxx101xxxxx0111x100111
10789                                                         st1d.  */
10790                                                      return 1821;
10791                                                    }
10792                                                }
10793                                            }
10794                                        }
10795                                      else
10796                                        {
10797                                          if (((word >> 31) & 0x1) == 0)
10798                                            {
10799                                              /* 33222222222211111111110000000000
10800                                                 10987654321098765432109876543210
10801                                                 xxxxxxxxxxxxx111xxxxx0xx1x100110
10802                                                 facgt.  */
10803                                              return 1335;
10804                                            }
10805                                          else
10806                                            {
10807                                              if (((word >> 20) & 0x1) == 0)
10808                                                {
10809                                                  /* 33222222222211111111110000000000
10810                                                     10987654321098765432109876543210
10811                                                     xxxxxxxxxxxxx111xxxx00xx1x100111
10812                                                     st1w.  */
10813                                                  return 1846;
10814                                                }
10815                                              else
10816                                                {
10817                                                  if (((word >> 22) & 0x1) == 0)
10818                                                    {
10819                                                      if (((word >> 23) & 0x1) == 0)
10820                                                        {
10821                                                          /* 33222222222211111111110000000000
10822                                                             10987654321098765432109876543210
10823                                                             xxxxxxxxxxxxx111xxxx10001x100111
10824                                                             stnt1w.  */
10825                                                          return 1880;
10826                                                        }
10827                                                      else
10828                                                        {
10829                                                          /* 33222222222211111111110000000000
10830                                                             10987654321098765432109876543210
10831                                                             xxxxxxxxxxxxx111xxxx10011x100111
10832                                                             stnt1d.  */
10833                                                          return 1876;
10834                                                        }
10835                                                    }
10836                                                  else
10837                                                    {
10838                                                      if (((word >> 23) & 0x1) == 0)
10839                                                        {
10840                                                          /* 33222222222211111111110000000000
10841                                                             10987654321098765432109876543210
10842                                                             xxxxxxxxxxxxx111xxxx10101x100111
10843                                                             st3w.  */
10844                                                          return 1864;
10845                                                        }
10846                                                      else
10847                                                        {
10848                                                          /* 33222222222211111111110000000000
10849                                                             10987654321098765432109876543210
10850                                                             xxxxxxxxxxxxx111xxxx10111x100111
10851                                                             st3d.  */
10852                                                          return 1860;
10853                                                        }
10854                                                    }
10855                                                }
10856                                            }
10857                                        }
10858                                    }
10859                                }
10860                            }
10861                          else
10862                            {
10863                              if (((word >> 30) & 0x1) == 0)
10864                                {
10865                                  if (((word >> 14) & 0x1) == 0)
10866                                    {
10867                                      if (((word >> 20) & 0x1) == 0)
10868                                        {
10869                                          if (((word >> 31) & 0x1) == 0)
10870                                            {
10871                                              if (((word >> 16) & 0x1) == 0)
10872                                                {
10873                                                  if (((word >> 17) & 0x1) == 0)
10874                                                    {
10875                                                      if (((word >> 18) & 0x1) == 0)
10876                                                        {
10877                                                          if (((word >> 19) & 0x1) == 0)
10878                                                            {
10879                                                              /* 33222222222211111111110000000000
10880                                                                 10987654321098765432109876543210
10881                                                                 xxxxxxxxxxxxxx01000001xx1x100100
10882                                                                 cntp.  */
10883                                                              return 1304;
10884                                                            }
10885                                                          else
10886                                                            {
10887                                                              if (((word >> 10) & 0x1) == 0)
10888                                                                {
10889                                                                  if (((word >> 11) & 0x1) == 0)
10890                                                                    {
10891                                                                      if (((word >> 12) & 0x1) == 0)
10892                                                                        {
10893                                                                          /* 33222222222211111111110000000000
10894                                                                             10987654321098765432109876543210
10895                                                                             xxxxxxxxxx000x01000101xx1x100100
10896                                                                             sqincp.  */
10897                                                                          return 1795;
10898                                                                        }
10899                                                                      else
10900                                                                        {
10901                                                                          /* 33222222222211111111110000000000
10902                                                                             10987654321098765432109876543210
10903                                                                             xxxxxxxxxx001x01000101xx1x100100
10904                                                                             wrffr.  */
10905                                                                          return 1968;
10906                                                                        }
10907                                                                    }
10908                                                                  else
10909                                                                    {
10910                                                                      /* 33222222222211111111110000000000
10911                                                                         10987654321098765432109876543210
10912                                                                         xxxxxxxxxx01xx01000101xx1x100100
10913                                                                         sqincp.  */
10914                                                                      return 1797;
10915                                                                    }
10916                                                                }
10917                                                              else
10918                                                                {
10919                                                                  /* 33222222222211111111110000000000
10920                                                                     10987654321098765432109876543210
10921                                                                     xxxxxxxxxx1xxx01000101xx1x100100
10922                                                                     sqincp.  */
10923                                                                  return 1796;
10924                                                                }
10925                                                            }
10926                                                        }
10927                                                      else
10928                                                        {
10929                                                          if (((word >> 11) & 0x1) == 0)
10930                                                            {
10931                                                              if (((word >> 12) & 0x1) == 0)
10932                                                                {
10933                                                                  /* 33222222222211111111110000000000
10934                                                                     10987654321098765432109876543210
10935                                                                     xxxxxxxxxxx00x01001x01xx1x100100
10936                                                                     incp.  */
10937                                                                  return 1442;
10938                                                                }
10939                                                              else
10940                                                                {
10941                                                                  /* 33222222222211111111110000000000
10942                                                                     10987654321098765432109876543210
10943                                                                     xxxxxxxxxxx01x01001x01xx1x100100
10944                                                                     setffr.  */
10945                                                                  return 1762;
10946                                                                }
10947                                                            }
10948                                                          else
10949                                                            {
10950                                                              /* 33222222222211111111110000000000
10951                                                                 10987654321098765432109876543210
10952                                                                 xxxxxxxxxxx1xx01001x01xx1x100100
10953                                                                 incp.  */
10954                                                              return 1443;
10955                                                            }
10956                                                        }
10957                                                    }
10958                                                  else
10959                                                    {
10960                                                      if (((word >> 10) & 0x1) == 0)
10961                                                        {
10962                                                          if (((word >> 11) & 0x1) == 0)
10963                                                            {
10964                                                              /* 33222222222211111111110000000000
10965                                                                 10987654321098765432109876543210
10966                                                                 xxxxxxxxxx00xx0101xx01xx1x100100
10967                                                                 sqdecp.  */
10968                                                              return 1781;
10969                                                            }
10970                                                          else
10971                                                            {
10972                                                              /* 33222222222211111111110000000000
10973                                                                 10987654321098765432109876543210
10974                                                                 xxxxxxxxxx01xx0101xx01xx1x100100
10975                                                                 sqdecp.  */
10976                                                              return 1783;
10977                                                            }
10978                                                        }
10979                                                      else
10980                                                        {
10981                                                          /* 33222222222211111111110000000000
10982                                                             10987654321098765432109876543210
10983                                                             xxxxxxxxxx1xxx0101xx01xx1x100100
10984                                                             sqdecp.  */
10985                                                          return 1782;
10986                                                        }
10987                                                    }
10988                                                }
10989                                              else
10990                                                {
10991                                                  if (((word >> 10) & 0x1) == 0)
10992                                                    {
10993                                                      if (((word >> 11) & 0x1) == 0)
10994                                                        {
10995                                                          if (((word >> 17) & 0x1) == 0)
10996                                                            {
10997                                                              if (((word >> 18) & 0x1) == 0)
10998                                                                {
10999                                                                  /* 33222222222211111111110000000000
11000                                                                     10987654321098765432109876543210
11001                                                                     xxxxxxxxxx00xx01100x01xx1x100100
11002                                                                     uqincp.  */
11003                                                                  return 1943;
11004                                                                }
11005                                                              else
11006                                                                {
11007                                                                  /* 33222222222211111111110000000000
11008                                                                     10987654321098765432109876543210
11009                                                                     xxxxxxxxxx00xx01101x01xx1x100100
11010                                                                     decp.  */
11011                                                                  return 1317;
11012                                                                }
11013                                                            }
11014                                                          else
11015                                                            {
11016                                                              /* 33222222222211111111110000000000
11017                                                                 10987654321098765432109876543210
11018                                                                 xxxxxxxxxx00xx0111xx01xx1x100100
11019                                                                 uqdecp.  */
11020                                                              return 1929;
11021                                                            }
11022                                                        }
11023                                                      else
11024                                                        {
11025                                                          if (((word >> 17) & 0x1) == 0)
11026                                                            {
11027                                                              if (((word >> 18) & 0x1) == 0)
11028                                                                {
11029                                                                  /* 33222222222211111111110000000000
11030                                                                     10987654321098765432109876543210
11031                                                                     xxxxxxxxxx01xx01100x01xx1x100100
11032                                                                     uqincp.  */
11033                                                                  return 1944;
11034                                                                }
11035                                                              else
11036                                                                {
11037                                                                  /* 33222222222211111111110000000000
11038                                                                     10987654321098765432109876543210
11039                                                                     xxxxxxxxxx01xx01101x01xx1x100100
11040                                                                     decp.  */
11041                                                                  return 1318;
11042                                                                }
11043                                                            }
11044                                                          else
11045                                                            {
11046                                                              /* 33222222222211111111110000000000
11047                                                                 10987654321098765432109876543210
11048                                                                 xxxxxxxxxx01xx0111xx01xx1x100100
11049                                                                 uqdecp.  */
11050                                                              return 1930;
11051                                                            }
11052                                                        }
11053                                                    }
11054                                                  else
11055                                                    {
11056                                                      if (((word >> 17) & 0x1) == 0)
11057                                                        {
11058                                                          /* 33222222222211111111110000000000
11059                                                             10987654321098765432109876543210
11060                                                             xxxxxxxxxx1xxx0110xx01xx1x100100
11061                                                             uqincp.  */
11062                                                          return 1945;
11063                                                        }
11064                                                      else
11065                                                        {
11066                                                          /* 33222222222211111111110000000000
11067                                                             10987654321098765432109876543210
11068                                                             xxxxxxxxxx1xxx0111xx01xx1x100100
11069                                                             uqdecp.  */
11070                                                          return 1931;
11071                                                        }
11072                                                    }
11073                                                }
11074                                            }
11075                                          else
11076                                            {
11077                                              if (((word >> 22) & 0x1) == 0)
11078                                                {
11079                                                  if (((word >> 23) & 0x1) == 0)
11080                                                    {
11081                                                      /* 33222222222211111111110000000000
11082                                                         10987654321098765432109876543210
11083                                                         xxxxxxxxxxxxxx01xxxx01001x100101
11084                                                         ld1sh.  */
11085                                                      return 1535;
11086                                                    }
11087                                                  else
11088                                                    {
11089                                                      /* 33222222222211111111110000000000
11090                                                         10987654321098765432109876543210
11091                                                         xxxxxxxxxxxxxx01xxxx01011x100101
11092                                                         ld1sb.  */
11093                                                      return 1522;
11094                                                    }
11095                                                }
11096                                              else
11097                                                {
11098                                                  if (((word >> 23) & 0x1) == 0)
11099                                                    {
11100                                                      /* 33222222222211111111110000000000
11101                                                         10987654321098765432109876543210
11102                                                         xxxxxxxxxxxxxx01xxxx01101x100101
11103                                                         ld1w.  */
11104                                                      return 1554;
11105                                                    }
11106                                                  else
11107                                                    {
11108                                                      /* 33222222222211111111110000000000
11109                                                         10987654321098765432109876543210
11110                                                         xxxxxxxxxxxxxx01xxxx01111x100101
11111                                                         ld1d.  */
11112                                                      return 1474;
11113                                                    }
11114                                                }
11115                                            }
11116                                        }
11117                                      else
11118                                        {
11119                                          if (((word >> 22) & 0x1) == 0)
11120                                            {
11121                                              if (((word >> 23) & 0x1) == 0)
11122                                                {
11123                                                  /* 33222222222211111111110000000000
11124                                                     10987654321098765432109876543210
11125                                                     xxxxxxxxxxxxxx01xxxx11001x10010x
11126                                                     ldnf1sh.  */
11127                                                  return 1652;
11128                                                }
11129                                              else
11130                                                {
11131                                                  /* 33222222222211111111110000000000
11132                                                     10987654321098765432109876543210
11133                                                     xxxxxxxxxxxxxx01xxxx11011x10010x
11134                                                     ldnf1sb.  */
11135                                                  return 1649;
11136                                                }
11137                                            }
11138                                          else
11139                                            {
11140                                              if (((word >> 23) & 0x1) == 0)
11141                                                {
11142                                                  /* 33222222222211111111110000000000
11143                                                     10987654321098765432109876543210
11144                                                     xxxxxxxxxxxxxx01xxxx11101x10010x
11145                                                     ldnf1w.  */
11146                                                  return 1655;
11147                                                }
11148                                              else
11149                                                {
11150                                                  /* 33222222222211111111110000000000
11151                                                     10987654321098765432109876543210
11152                                                     xxxxxxxxxxxxxx01xxxx11111x10010x
11153                                                     ldnf1d.  */
11154                                                  return 1644;
11155                                                }
11156                                            }
11157                                        }
11158                                    }
11159                                  else
11160                                    {
11161                                      if (((word >> 31) & 0x1) == 0)
11162                                        {
11163                                          if (((word >> 16) & 0x1) == 0)
11164                                            {
11165                                              if (((word >> 17) & 0x1) == 0)
11166                                                {
11167                                                  if (((word >> 18) & 0x1) == 0)
11168                                                    {
11169                                                      if (((word >> 19) & 0x1) == 0)
11170                                                        {
11171                                                          if (((word >> 20) & 0x1) == 0)
11172                                                            {
11173                                                              /* 33222222222211111111110000000000
11174                                                                 10987654321098765432109876543210
11175                                                                 xxxxxxxxxxxxxx11000001xx1x100100
11176                                                                 add.  */
11177                                                              return 1231;
11178                                                            }
11179                                                          else
11180                                                            {
11181                                                              /* 33222222222211111111110000000000
11182                                                                 10987654321098765432109876543210
11183                                                                 xxxxxxxxxxxxxx11000011xx1x100100
11184                                                                 mul.  */
11185                                                              return 1684;
11186                                                            }
11187                                                        }
11188                                                      else
11189                                                        {
11190                                                          if (((word >> 20) & 0x1) == 0)
11191                                                            {
11192                                                              /* 33222222222211111111110000000000
11193                                                                 10987654321098765432109876543210
11194                                                                 xxxxxxxxxxxxxx11000101xx1x100100
11195                                                                 smax.  */
11196                                                              return 1763;
11197                                                            }
11198                                                          else
11199                                                            {
11200                                                              /* 33222222222211111111110000000000
11201                                                                 10987654321098765432109876543210
11202                                                                 xxxxxxxxxxxxxx11000111xx1x100100
11203                                                                 dup.  */
11204                                                              return 1323;
11205                                                            }
11206                                                        }
11207                                                    }
11208                                                  else
11209                                                    {
11210                                                      /* 33222222222211111111110000000000
11211                                                         10987654321098765432109876543210
11212                                                         xxxxxxxxxxxxxx11001xx1xx1x100100
11213                                                         sqadd.  */
11214                                                      return 1772;
11215                                                    }
11216                                                }
11217                                              else
11218                                                {
11219                                                  if (((word >> 18) & 0x1) == 0)
11220                                                    {
11221                                                      /* 33222222222211111111110000000000
11222                                                         10987654321098765432109876543210
11223                                                         xxxxxxxxxxxxxx11010xx1xx1x100100
11224                                                         smin.  */
11225                                                      return 1766;
11226                                                    }
11227                                                  else
11228                                                    {
11229                                                      /* 33222222222211111111110000000000
11230                                                         10987654321098765432109876543210
11231                                                         xxxxxxxxxxxxxx11011xx1xx1x100100
11232                                                         sqsub.  */
11233                                                      return 1802;
11234                                                    }
11235                                                }
11236                                            }
11237                                          else
11238                                            {
11239                                              if (((word >> 17) & 0x1) == 0)
11240                                                {
11241                                                  if (((word >> 18) & 0x1) == 0)
11242                                                    {
11243                                                      if (((word >> 19) & 0x1) == 0)
11244                                                        {
11245                                                          /* 33222222222211111111110000000000
11246                                                             10987654321098765432109876543210
11247                                                             xxxxxxxxxxxxxx111000x1xx1x100100
11248                                                             sub.  */
11249                                                          return 1884;
11250                                                        }
11251                                                      else
11252                                                        {
11253                                                          if (((word >> 20) & 0x1) == 0)
11254                                                            {
11255                                                              /* 33222222222211111111110000000000
11256                                                                 10987654321098765432109876543210
11257                                                                 xxxxxxxxxxxxxx11100101xx1x100100
11258                                                                 umax.  */
11259                                                              return 1912;
11260                                                            }
11261                                                          else
11262                                                            {
11263                                                              /* 33222222222211111111110000000000
11264                                                                 10987654321098765432109876543210
11265                                                                 xxxxxxxxxxxxxx11100111xx1x100100
11266                                                                 fdup.  */
11267                                                              return 1379;
11268                                                            }
11269                                                        }
11270                                                    }
11271                                                  else
11272                                                    {
11273                                                      /* 33222222222211111111110000000000
11274                                                         10987654321098765432109876543210
11275                                                         xxxxxxxxxxxxxx11101xx1xx1x100100
11276                                                         uqadd.  */
11277                                                      return 1920;
11278                                                    }
11279                                                }
11280                                              else
11281                                                {
11282                                                  if (((word >> 18) & 0x1) == 0)
11283                                                    {
11284                                                      if (((word >> 19) & 0x1) == 0)
11285                                                        {
11286                                                          /* 33222222222211111111110000000000
11287                                                             10987654321098765432109876543210
11288                                                             xxxxxxxxxxxxxx111100x1xx1x100100
11289                                                             subr.  */
11290                                                          return 1886;
11291                                                        }
11292                                                      else
11293                                                        {
11294                                                          /* 33222222222211111111110000000000
11295                                                             10987654321098765432109876543210
11296                                                             xxxxxxxxxxxxxx111101x1xx1x100100
11297                                                             umin.  */
11298                                                          return 1915;
11299                                                        }
11300                                                    }
11301                                                  else
11302                                                    {
11303                                                      /* 33222222222211111111110000000000
11304                                                         10987654321098765432109876543210
11305                                                         xxxxxxxxxxxxxx11111xx1xx1x100100
11306                                                         uqsub.  */
11307                                                      return 1950;
11308                                                    }
11309                                                }
11310                                            }
11311                                        }
11312                                      else
11313                                        {
11314                                          if (((word >> 13) & 0x1) == 0)
11315                                            {
11316                                              if (((word >> 22) & 0x1) == 0)
11317                                                {
11318                                                  if (((word >> 23) & 0x1) == 0)
11319                                                    {
11320                                                      /* 33222222222211111111110000000000
11321                                                         10987654321098765432109876543210
11322                                                         xxxxxxxxxxxxx011xxxxx1001x100101
11323                                                         ld2w.  */
11324                                                      return 1562;
11325                                                    }
11326                                                  else
11327                                                    {
11328                                                      /* 33222222222211111111110000000000
11329                                                         10987654321098765432109876543210
11330                                                         xxxxxxxxxxxxx011xxxxx1011x100101
11331                                                         ld2d.  */
11332                                                      return 1558;
11333                                                    }
11334                                                }
11335                                              else
11336                                                {
11337                                                  if (((word >> 23) & 0x1) == 0)
11338                                                    {
11339                                                      /* 33222222222211111111110000000000
11340                                                         10987654321098765432109876543210
11341                                                         xxxxxxxxxxxxx011xxxxx1101x100101
11342                                                         ld4w.  */
11343                                                      return 1578;
11344                                                    }
11345                                                  else
11346                                                    {
11347                                                      /* 33222222222211111111110000000000
11348                                                         10987654321098765432109876543210
11349                                                         xxxxxxxxxxxxx011xxxxx1111x100101
11350                                                         ld4d.  */
11351                                                      return 1574;
11352                                                    }
11353                                                }
11354                                            }
11355                                          else
11356                                            {
11357                                              if (((word >> 22) & 0x1) == 0)
11358                                                {
11359                                                  if (((word >> 23) & 0x1) == 0)
11360                                                    {
11361                                                      /* 33222222222211111111110000000000
11362                                                         10987654321098765432109876543210
11363                                                         xxxxxxxxxxxxx111xxxxx1001x100101
11364                                                         ld2w.  */
11365                                                      return 1563;
11366                                                    }
11367                                                  else
11368                                                    {
11369                                                      /* 33222222222211111111110000000000
11370                                                         10987654321098765432109876543210
11371                                                         xxxxxxxxxxxxx111xxxxx1011x100101
11372                                                         ld2d.  */
11373                                                      return 1559;
11374                                                    }
11375                                                }
11376                                              else
11377                                                {
11378                                                  if (((word >> 23) & 0x1) == 0)
11379                                                    {
11380                                                      /* 33222222222211111111110000000000
11381                                                         10987654321098765432109876543210
11382                                                         xxxxxxxxxxxxx111xxxxx1101x100101
11383                                                         ld4w.  */
11384                                                      return 1579;
11385                                                    }
11386                                                  else
11387                                                    {
11388                                                      /* 33222222222211111111110000000000
11389                                                         10987654321098765432109876543210
11390                                                         xxxxxxxxxxxxx111xxxxx1111x100101
11391                                                         ld4d.  */
11392                                                      return 1575;
11393                                                    }
11394                                                }
11395                                            }
11396                                        }
11397                                    }
11398                                }
11399                              else
11400                                {
11401                                  if (((word >> 13) & 0x1) == 0)
11402                                    {
11403                                      if (((word >> 31) & 0x1) == 0)
11404                                        {
11405                                          if (((word >> 14) & 0x1) == 0)
11406                                            {
11407                                              /* 33222222222211111111110000000000
11408                                                 10987654321098765432109876543210
11409                                                 xxxxxxxxxxxxx001xxxxx1xx1x100110
11410                                                 fmad.  */
11411                                              return 1381;
11412                                            }
11413                                          else
11414                                            {
11415                                              /* 33222222222211111111110000000000
11416                                                 10987654321098765432109876543210
11417                                                 xxxxxxxxxxxxx011xxxxx1xx1x100110
11418                                                 fnmad.  */
11419                                              return 1411;
11420                                            }
11421                                        }
11422                                      else
11423                                        {
11424                                          if (((word >> 22) & 0x1) == 0)
11425                                            {
11426                                              if (((word >> 23) & 0x1) == 0)
11427                                                {
11428                                                  /* 33222222222211111111110000000000
11429                                                     10987654321098765432109876543210
11430                                                     xxxxxxxxxxxxx0x1xxxxx1001x100111
11431                                                     st1w.  */
11432                                                  return 1839;
11433                                                }
11434                                              else
11435                                                {
11436                                                  /* 33222222222211111111110000000000
11437                                                     10987654321098765432109876543210
11438                                                     xxxxxxxxxxxxx0x1xxxxx1011x100111
11439                                                     st1d.  */
11440                                                  return 1818;
11441                                                }
11442                                            }
11443                                          else
11444                                            {
11445                                              /* 33222222222211111111110000000000
11446                                                 10987654321098765432109876543210
11447                                                 xxxxxxxxxxxxx0x1xxxxx11x1x100111
11448                                                 st1w.  */
11449                                              return 1844;
11450                                            }
11451                                        }
11452                                    }
11453                                  else
11454                                    {
11455                                      if (((word >> 14) & 0x1) == 0)
11456                                        {
11457                                          if (((word >> 31) & 0x1) == 0)
11458                                            {
11459                                              /* 33222222222211111111110000000000
11460                                                 10987654321098765432109876543210
11461                                                 xxxxxxxxxxxxx101xxxxx1xx1x100110
11462                                                 fmsb.  */
11463                                              return 1402;
11464                                            }
11465                                          else
11466                                            {
11467                                              if (((word >> 22) & 0x1) == 0)
11468                                                {
11469                                                  if (((word >> 23) & 0x1) == 0)
11470                                                    {
11471                                                      /* 33222222222211111111110000000000
11472                                                         10987654321098765432109876543210
11473                                                         xxxxxxxxxxxxx101xxxxx1001x100111
11474                                                         st1w.  */
11475                                                      return 1840;
11476                                                    }
11477                                                  else
11478                                                    {
11479                                                      /* 33222222222211111111110000000000
11480                                                         10987654321098765432109876543210
11481                                                         xxxxxxxxxxxxx101xxxxx1011x100111
11482                                                         st1d.  */
11483                                                      return 1819;
11484                                                    }
11485                                                }
11486                                              else
11487                                                {
11488                                                  /* 33222222222211111111110000000000
11489                                                     10987654321098765432109876543210
11490                                                     xxxxxxxxxxxxx101xxxxx11x1x100111
11491                                                     st1w.  */
11492                                                  return 1847;
11493                                                }
11494                                            }
11495                                        }
11496                                      else
11497                                        {
11498                                          if (((word >> 31) & 0x1) == 0)
11499                                            {
11500                                              /* 33222222222211111111110000000000
11501                                                 10987654321098765432109876543210
11502                                                 xxxxxxxxxxxxx111xxxxx1xx1x100110
11503                                                 fnmsb.  */
11504                                              return 1414;
11505                                            }
11506                                          else
11507                                            {
11508                                              if (((word >> 20) & 0x1) == 0)
11509                                                {
11510                                                  if (((word >> 23) & 0x1) == 0)
11511                                                    {
11512                                                      /* 33222222222211111111110000000000
11513                                                         10987654321098765432109876543210
11514                                                         xxxxxxxxxxxxx111xxxx01x01x100111
11515                                                         st1w.  */
11516                                                      return 1848;
11517                                                    }
11518                                                  else
11519                                                    {
11520                                                      /* 33222222222211111111110000000000
11521                                                         10987654321098765432109876543210
11522                                                         xxxxxxxxxxxxx111xxxx01x11x100111
11523                                                         st1d.  */
11524                                                      return 1822;
11525                                                    }
11526                                                }
11527                                              else
11528                                                {
11529                                                  if (((word >> 22) & 0x1) == 0)
11530                                                    {
11531                                                      if (((word >> 23) & 0x1) == 0)
11532                                                        {
11533                                                          /* 33222222222211111111110000000000
11534                                                             10987654321098765432109876543210
11535                                                             xxxxxxxxxxxxx111xxxx11001x100111
11536                                                             st2w.  */
11537                                                          return 1856;
11538                                                        }
11539                                                      else
11540                                                        {
11541                                                          /* 33222222222211111111110000000000
11542                                                             10987654321098765432109876543210
11543                                                             xxxxxxxxxxxxx111xxxx11011x100111
11544                                                             st2d.  */
11545                                                          return 1852;
11546                                                        }
11547                                                    }
11548                                                  else
11549                                                    {
11550                                                      if (((word >> 23) & 0x1) == 0)
11551                                                        {
11552                                                          /* 33222222222211111111110000000000
11553                                                             10987654321098765432109876543210
11554                                                             xxxxxxxxxxxxx111xxxx11101x100111
11555                                                             st4w.  */
11556                                                          return 1872;
11557                                                        }
11558                                                      else
11559                                                        {
11560                                                          /* 33222222222211111111110000000000
11561                                                             10987654321098765432109876543210
11562                                                             xxxxxxxxxxxxx111xxxx11111x100111
11563                                                             st4d.  */
11564                                                          return 1868;
11565                                                        }
11566                                                    }
11567                                                }
11568                                            }
11569                                        }
11570                                    }
11571                                }
11572                            }
11573                        }
11574                    }
11575                }
11576            }
11577          else
11578            {
11579              if (((word >> 29) & 0x1) == 0)
11580                {
11581                  if (((word >> 30) & 0x1) == 0)
11582                    {
11583                      if (((word >> 31) & 0x1) == 0)
11584                        {
11585                          /* 33222222222211111111110000000000
11586                             10987654321098765432109876543210
11587                             xxxxxxxxxxxxxxxxxxxxxxxxxx101000
11588                             b.  */
11589                          return 630;
11590                        }
11591                      else
11592                        {
11593                          /* 33222222222211111111110000000000
11594                             10987654321098765432109876543210
11595                             xxxxxxxxxxxxxxxxxxxxxxxxxx101001
11596                             bl.  */
11597                          return 631;
11598                        }
11599                    }
11600                  else
11601                    {
11602                      if (((word >> 24) & 0x1) == 0)
11603                        {
11604                          if (((word >> 4) & 0x1) == 0)
11605                            {
11606                              if (((word >> 25) & 0x1) == 0)
11607                                {
11608                                  if (((word >> 31) & 0x1) == 0)
11609                                    {
11610                                      /* 33222222222211111111110000000000
11611                                         10987654321098765432109876543210
11612                                         xxxx0xxxxxxxxxxxxxxxxxxx00101010
11613                                         b.c.  */
11614                                      return 651;
11615                                    }
11616                                  else
11617                                    {
11618                                      if (((word >> 0) & 0x1) == 0)
11619                                        {
11620                                          if (((word >> 1) & 0x1) == 0)
11621                                            {
11622                                              if (((word >> 21) & 0x1) == 0)
11623                                                {
11624                                                  /* 33222222222211111111110000000000
11625                                                     10987654321098765432109876543210
11626                                                     00xx0xxxxxxxxxxxxxxxx0xx00101011
11627                                                     hlt.  */
11628                                                  return 742;
11629                                                }
11630                                              else
11631                                                {
11632                                                  /* 33222222222211111111110000000000
11633                                                     10987654321098765432109876543210
11634                                                     00xx0xxxxxxxxxxxxxxxx1xx00101011
11635                                                     brk.  */
11636                                                  return 741;
11637                                                }
11638                                            }
11639                                          else
11640                                            {
11641                                              if (((word >> 21) & 0x1) == 0)
11642                                                {
11643                                                  /* 33222222222211111111110000000000
11644                                                     10987654321098765432109876543210
11645                                                     01xx0xxxxxxxxxxxxxxxx0xx00101011
11646                                                     hvc.  */
11647                                                  return 739;
11648                                                }
11649                                              else
11650                                                {
11651                                                  /* 33222222222211111111110000000000
11652                                                     10987654321098765432109876543210
11653                                                     01xx0xxxxxxxxxxxxxxxx1xx00101011
11654                                                     dcps2.  */
11655                                                  return 744;
11656                                                }
11657                                            }
11658                                        }
11659                                      else
11660                                        {
11661                                          if (((word >> 1) & 0x1) == 0)
11662                                            {
11663                                              if (((word >> 21) & 0x1) == 0)
11664                                                {
11665                                                  /* 33222222222211111111110000000000
11666                                                     10987654321098765432109876543210
11667                                                     10xx0xxxxxxxxxxxxxxxx0xx00101011
11668                                                     svc.  */
11669                                                  return 738;
11670                                                }
11671                                              else
11672                                                {
11673                                                  /* 33222222222211111111110000000000
11674                                                     10987654321098765432109876543210
11675                                                     10xx0xxxxxxxxxxxxxxxx1xx00101011
11676                                                     dcps1.  */
11677                                                  return 743;
11678                                                }
11679                                            }
11680                                          else
11681                                            {
11682                                              if (((word >> 21) & 0x1) == 0)
11683                                                {
11684                                                  /* 33222222222211111111110000000000
11685                                                     10987654321098765432109876543210
11686                                                     11xx0xxxxxxxxxxxxxxxx0xx00101011
11687                                                     smc.  */
11688                                                  return 740;
11689                                                }
11690                                              else
11691                                                {
11692                                                  /* 33222222222211111111110000000000
11693                                                     10987654321098765432109876543210
11694                                                     11xx0xxxxxxxxxxxxxxxx1xx00101011
11695                                                     dcps3.  */
11696                                                  return 745;
11697                                                }
11698                                            }
11699                                        }
11700                                    }
11701                                }
11702                              else
11703                                {
11704                                  if (((word >> 21) & 0x1) == 0)
11705                                    {
11706                                      if (((word >> 22) & 0x1) == 0)
11707                                        {
11708                                          if (((word >> 23) & 0x1) == 0)
11709                                            {
11710                                              /* 33222222222211111111110000000000
11711                                                 10987654321098765432109876543210
11712                                                 xxxx0xxxxxxxxxxxxxxxx0000110101x
11713                                                 br.  */
11714                                              return 632;
11715                                            }
11716                                          else
11717                                            {
11718                                              /* 33222222222211111111110000000000
11719                                                 10987654321098765432109876543210
11720                                                 xxxx0xxxxxxxxxxxxxxxx0010110101x
11721                                                 eret.  */
11722                                              return 635;
11723                                            }
11724                                        }
11725                                      else
11726                                        {
11727                                          /* 33222222222211111111110000000000
11728                                             10987654321098765432109876543210
11729                                             xxxx0xxxxxxxxxxxxxxxx01x0110101x
11730                                             ret.  */
11731                                          return 634;
11732                                        }
11733                                    }
11734                                  else
11735                                    {
11736                                      if (((word >> 23) & 0x1) == 0)
11737                                        {
11738                                          /* 33222222222211111111110000000000
11739                                             10987654321098765432109876543210
11740                                             xxxx0xxxxxxxxxxxxxxxx1x00110101x
11741                                             blr.  */
11742                                          return 633;
11743                                        }
11744                                      else
11745                                        {
11746                                          /* 33222222222211111111110000000000
11747                                             10987654321098765432109876543210
11748                                             xxxx0xxxxxxxxxxxxxxxx1x10110101x
11749                                             drps.  */
11750                                          return 636;
11751                                        }
11752                                    }
11753                                }
11754                            }
11755                          else
11756                            {
11757                              if (((word >> 10) & 0x1) == 0)
11758                                {
11759                                  if (((word >> 21) & 0x1) == 0)
11760                                    {
11761                                      if (((word >> 22) & 0x1) == 0)
11762                                        {
11763                                          if (((word >> 23) & 0x1) == 0)
11764                                            {
11765                                              /* 33222222222211111111110000000000
11766                                                 10987654321098765432109876543210
11767                                                 xxxx1xxxxx0xxxxxxxxxx0000x10101x
11768                                                 braaz.  */
11769                                              return 641;
11770                                            }
11771                                          else
11772                                            {
11773                                              /* 33222222222211111111110000000000
11774                                                 10987654321098765432109876543210
11775                                                 xxxx1xxxxx0xxxxxxxxxx0010x10101x
11776                                                 eretaa.  */
11777                                              return 647;
11778                                            }
11779                                        }
11780                                      else
11781                                        {
11782                                          /* 33222222222211111111110000000000
11783                                             10987654321098765432109876543210
11784                                             xxxx1xxxxx0xxxxxxxxxx01x0x10101x
11785                                             retaa.  */
11786                                          return 645;
11787                                        }
11788                                    }
11789                                  else
11790                                    {
11791                                      /* 33222222222211111111110000000000
11792                                         10987654321098765432109876543210
11793                                         xxxx1xxxxx0xxxxxxxxxx1xx0x10101x
11794                                         blraaz.  */
11795                                      return 643;
11796                                    }
11797                                }
11798                              else
11799                                {
11800                                  if (((word >> 21) & 0x1) == 0)
11801                                    {
11802                                      if (((word >> 22) & 0x1) == 0)
11803                                        {
11804                                          if (((word >> 23) & 0x1) == 0)
11805                                            {
11806                                              /* 33222222222211111111110000000000
11807                                                 10987654321098765432109876543210
11808                                                 xxxx1xxxxx1xxxxxxxxxx0000x10101x
11809                                                 brabz.  */
11810                                              return 642;
11811                                            }
11812                                          else
11813                                            {
11814                                              /* 33222222222211111111110000000000
11815                                                 10987654321098765432109876543210
11816                                                 xxxx1xxxxx1xxxxxxxxxx0010x10101x
11817                                                 eretab.  */
11818                                              return 648;
11819                                            }
11820                                        }
11821                                      else
11822                                        {
11823                                          /* 33222222222211111111110000000000
11824                                             10987654321098765432109876543210
11825                                             xxxx1xxxxx1xxxxxxxxxx01x0x10101x
11826                                             retab.  */
11827                                          return 646;
11828                                        }
11829                                    }
11830                                  else
11831                                    {
11832                                      /* 33222222222211111111110000000000
11833                                         10987654321098765432109876543210
11834                                         xxxx1xxxxx1xxxxxxxxxx1xx0x10101x
11835                                         blrabz.  */
11836                                      return 644;
11837                                    }
11838                                }
11839                            }
11840                        }
11841                      else
11842                        {
11843                          if (((word >> 21) & 0x1) == 0)
11844                            {
11845                              if (((word >> 25) & 0x1) == 0)
11846                                {
11847                                  /* 33222222222211111111110000000000
11848                                     10987654321098765432109876543210
11849                                     xxxxxxxxxxxxxxxxxxxxx0xx1010101x
11850                                     msr.  */
11851                                  return 1157;
11852                                }
11853                              else
11854                                {
11855                                  if (((word >> 10) & 0x1) == 0)
11856                                    {
11857                                      /* 33222222222211111111110000000000
11858                                         10987654321098765432109876543210
11859                                         xxxxxxxxxx0xxxxxxxxxx0xx1110101x
11860                                         braa.  */
11861                                      return 637;
11862                                    }
11863                                  else
11864                                    {
11865                                      /* 33222222222211111111110000000000
11866                                         10987654321098765432109876543210
11867                                         xxxxxxxxxx1xxxxxxxxxx0xx1110101x
11868                                         brab.  */
11869                                      return 638;
11870                                    }
11871                                }
11872                            }
11873                          else
11874                            {
11875                              if (((word >> 25) & 0x1) == 0)
11876                                {
11877                                  /* 33222222222211111111110000000000
11878                                     10987654321098765432109876543210
11879                                     xxxxxxxxxxxxxxxxxxxxx1xx1010101x
11880                                     sysl.  */
11881                                  return 1182;
11882                                }
11883                              else
11884                                {
11885                                  if (((word >> 10) & 0x1) == 0)
11886                                    {
11887                                      /* 33222222222211111111110000000000
11888                                         10987654321098765432109876543210
11889                                         xxxxxxxxxx0xxxxxxxxxx1xx1110101x
11890                                         blraa.  */
11891                                      return 639;
11892                                    }
11893                                  else
11894                                    {
11895                                      /* 33222222222211111111110000000000
11896                                         10987654321098765432109876543210
11897                                         xxxxxxxxxx1xxxxxxxxxx1xx1110101x
11898                                         blrab.  */
11899                                      return 640;
11900                                    }
11901                                }
11902                            }
11903                        }
11904                    }
11905                }
11906              else
11907                {
11908                  if (((word >> 24) & 0x1) == 0)
11909                    {
11910                      if (((word >> 25) & 0x1) == 0)
11911                        {
11912                          /* 33222222222211111111110000000000
11913                             10987654321098765432109876543210
11914                             xxxxxxxxxxxxxxxxxxxxxxxx001011xx
11915                             cbz.  */
11916                          return 649;
11917                        }
11918                      else
11919                        {
11920                          /* 33222222222211111111110000000000
11921                             10987654321098765432109876543210
11922                             xxxxxxxxxxxxxxxxxxxxxxxx011011xx
11923                             tbz.  */
11924                          return 1192;
11925                        }
11926                    }
11927                  else
11928                    {
11929                      if (((word >> 25) & 0x1) == 0)
11930                        {
11931                          /* 33222222222211111111110000000000
11932                             10987654321098765432109876543210
11933                             xxxxxxxxxxxxxxxxxxxxxxxx101011xx
11934                             cbnz.  */
11935                          return 650;
11936                        }
11937                      else
11938                        {
11939                          /* 33222222222211111111110000000000
11940                             10987654321098765432109876543210
11941                             xxxxxxxxxxxxxxxxxxxxxxxx111011xx
11942                             tbnz.  */
11943                          return 1193;
11944                        }
11945                    }
11946                }
11947            }
11948        }
11949      else
11950        {
11951          if (((word >> 25) & 0x1) == 0)
11952            {
11953              if (((word >> 28) & 0x1) == 0)
11954                {
11955                  if (((word >> 22) & 0x1) == 0)
11956                    {
11957                      if (((word >> 23) & 0x1) == 0)
11958                        {
11959                          if (((word >> 24) & 0x1) == 0)
11960                            {
11961                              if (((word >> 29) & 0x1) == 0)
11962                                {
11963                                  /* 33222222222211111111110000000000
11964                                     10987654321098765432109876543210
11965                                     xxxxxxxxxxxxxxxxxxxxxx00001100xx
11966                                     st4.  */
11967                                  return 434;
11968                                }
11969                              else
11970                                {
11971                                  /* 33222222222211111111110000000000
11972                                     10987654321098765432109876543210
11973                                     xxxxxxxxxxxxxxxxxxxxxx00001101xx
11974                                     stnp.  */
11975                                  return 943;
11976                                }
11977                            }
11978                          else
11979                            {
11980                              if (((word >> 29) & 0x1) == 0)
11981                                {
11982                                  if (((word >> 13) & 0x1) == 0)
11983                                    {
11984                                      if (((word >> 21) & 0x1) == 0)
11985                                        {
11986                                          /* 33222222222211111111110000000000
11987                                             10987654321098765432109876543210
11988                                             xxxxxxxxxxxxx0xxxxxxx000101100xx
11989                                             st1.  */
11990                                          return 450;
11991                                        }
11992                                      else
11993                                        {
11994                                          /* 33222222222211111111110000000000
11995                                             10987654321098765432109876543210
11996                                             xxxxxxxxxxxxx0xxxxxxx100101100xx
11997                                             st2.  */
11998                                          return 452;
11999                                        }
12000                                    }
12001                                  else
12002                                    {
12003                                      if (((word >> 21) & 0x1) == 0)
12004                                        {
12005                                          /* 33222222222211111111110000000000
12006                                             10987654321098765432109876543210
12007                                             xxxxxxxxxxxxx1xxxxxxx000101100xx
12008                                             st3.  */
12009                                          return 451;
12010                                        }
12011                                      else
12012                                        {
12013                                          /* 33222222222211111111110000000000
12014                                             10987654321098765432109876543210
12015                                             xxxxxxxxxxxxx1xxxxxxx100101100xx
12016                                             st4.  */
12017                                          return 453;
12018                                        }
12019                                    }
12020                                }
12021                              else
12022                                {
12023                                  /* 33222222222211111111110000000000
12024                                     10987654321098765432109876543210
12025                                     xxxxxxxxxxxxxxxxxxxxxx00101101xx
12026                                     stp.  */
12027                                  return 947;
12028                                }
12029                            }
12030                        }
12031                      else
12032                        {
12033                          if (((word >> 29) & 0x1) == 0)
12034                            {
12035                              if (((word >> 21) & 0x1) == 0)
12036                                {
12037                                  if (((word >> 24) & 0x1) == 0)
12038                                    {
12039                                      /* 33222222222211111111110000000000
12040                                         10987654321098765432109876543210
12041                                         xxxxxxxxxxxxxxxxxxxxx001001100xx
12042                                         st4.  */
12043                                      return 442;
12044                                    }
12045                                  else
12046                                    {
12047                                      if (((word >> 13) & 0x1) == 0)
12048                                        {
12049                                          /* 33222222222211111111110000000000
12050                                             10987654321098765432109876543210
12051                                             xxxxxxxxxxxxx0xxxxxxx001101100xx
12052                                             st1.  */
12053                                          return 462;
12054                                        }
12055                                      else
12056                                        {
12057                                          /* 33222222222211111111110000000000
12058                                             10987654321098765432109876543210
12059                                             xxxxxxxxxxxxx1xxxxxxx001101100xx
12060                                             st3.  */
12061                                          return 463;
12062                                        }
12063                                    }
12064                                }
12065                              else
12066                                {
12067                                  if (((word >> 13) & 0x1) == 0)
12068                                    {
12069                                      /* 33222222222211111111110000000000
12070                                         10987654321098765432109876543210
12071                                         xxxxxxxxxxxxx0xxxxxxx101x01100xx
12072                                         st2.  */
12073                                      return 464;
12074                                    }
12075                                  else
12076                                    {
12077                                      /* 33222222222211111111110000000000
12078                                         10987654321098765432109876543210
12079                                         xxxxxxxxxxxxx1xxxxxxx101x01100xx
12080                                         st4.  */
12081                                      return 465;
12082                                    }
12083                                }
12084                            }
12085                          else
12086                            {
12087                              /* 33222222222211111111110000000000
12088                                 10987654321098765432109876543210
12089                                 xxxxxxxxxxxxxxxxxxxxxx01x01101xx
12090                                 stp.  */
12091                              return 952;
12092                            }
12093                        }
12094                    }
12095                  else
12096                    {
12097                      if (((word >> 23) & 0x1) == 0)
12098                        {
12099                          if (((word >> 24) & 0x1) == 0)
12100                            {
12101                              if (((word >> 29) & 0x1) == 0)
12102                                {
12103                                  /* 33222222222211111111110000000000
12104                                     10987654321098765432109876543210
12105                                     xxxxxxxxxxxxxxxxxxxxxx10001100xx
12106                                     ld4.  */
12107                                  return 438;
12108                                }
12109                              else
12110                                {
12111                                  /* 33222222222211111111110000000000
12112                                     10987654321098765432109876543210
12113                                     xxxxxxxxxxxxxxxxxxxxxx10001101xx
12114                                     ldnp.  */
12115                                  return 944;
12116                                }
12117                            }
12118                          else
12119                            {
12120                              if (((word >> 29) & 0x1) == 0)
12121                                {
12122                                  if (((word >> 13) & 0x1) == 0)
12123                                    {
12124                                      if (((word >> 21) & 0x1) == 0)
12125                                        {
12126                                          /* 33222222222211111111110000000000
12127                                             10987654321098765432109876543210
12128                                             xxxxxxxxxxxxx0xxxxxxx010101100xx
12129                                             ld1.  */
12130                                          return 454;
12131                                        }
12132                                      else
12133                                        {
12134                                          /* 33222222222211111111110000000000
12135                                             10987654321098765432109876543210
12136                                             xxxxxxxxxxxxx0xxxxxxx110101100xx
12137                                             ld2.  */
12138                                          return 458;
12139                                        }
12140                                    }
12141                                  else
12142                                    {
12143                                      if (((word >> 21) & 0x1) == 0)
12144                                        {
12145                                          /* 33222222222211111111110000000000
12146                                             10987654321098765432109876543210
12147                                             xxxxxxxxxxxxx1xxxxxxx010101100xx
12148                                             ld3.  */
12149                                          return 455;
12150                                        }
12151                                      else
12152                                        {
12153                                          /* 33222222222211111111110000000000
12154                                             10987654321098765432109876543210
12155                                             xxxxxxxxxxxxx1xxxxxxx110101100xx
12156                                             ld4.  */
12157                                          return 459;
12158                                        }
12159                                    }
12160                                }
12161                              else
12162                                {
12163                                  /* 33222222222211111111110000000000
12164                                     10987654321098765432109876543210
12165                                     xxxxxxxxxxxxxxxxxxxxxx10101101xx
12166                                     ldp.  */
12167                                  return 948;
12168                                }
12169                            }
12170                        }
12171                      else
12172                        {
12173                          if (((word >> 29) & 0x1) == 0)
12174                            {
12175                              if (((word >> 21) & 0x1) == 0)
12176                                {
12177                                  if (((word >> 24) & 0x1) == 0)
12178                                    {
12179                                      /* 33222222222211111111110000000000
12180                                         10987654321098765432109876543210
12181                                         xxxxxxxxxxxxxxxxxxxxx011001100xx
12182                                         ld4.  */
12183                                      return 446;
12184                                    }
12185                                  else
12186                                    {
12187                                      if (((word >> 13) & 0x1) == 0)
12188                                        {
12189                                          /* 33222222222211111111110000000000
12190                                             10987654321098765432109876543210
12191                                             xxxxxxxxxxxxx0xxxxxxx011101100xx
12192                                             ld1.  */
12193                                          return 466;
12194                                        }
12195                                      else
12196                                        {
12197                                          /* 33222222222211111111110000000000
12198                                             10987654321098765432109876543210
12199                                             xxxxxxxxxxxxx1xxxxxxx011101100xx
12200                                             ld3.  */
12201                                          return 467;
12202                                        }
12203                                    }
12204                                }
12205                              else
12206                                {
12207                                  if (((word >> 13) & 0x1) == 0)
12208                                    {
12209                                      /* 33222222222211111111110000000000
12210                                         10987654321098765432109876543210
12211                                         xxxxxxxxxxxxx0xxxxxxx111x01100xx
12212                                         ld2.  */
12213                                      return 470;
12214                                    }
12215                                  else
12216                                    {
12217                                      /* 33222222222211111111110000000000
12218                                         10987654321098765432109876543210
12219                                         xxxxxxxxxxxxx1xxxxxxx111x01100xx
12220                                         ld4.  */
12221                                      return 471;
12222                                    }
12223                                }
12224                            }
12225                          else
12226                            {
12227                              /* 33222222222211111111110000000000
12228                                 10987654321098765432109876543210
12229                                 xxxxxxxxxxxxxxxxxxxxxx11x01101xx
12230                                 ldp.  */
12231                              return 953;
12232                            }
12233                        }
12234                    }
12235                }
12236              else
12237                {
12238                  if (((word >> 24) & 0x1) == 0)
12239                    {
12240                      if (((word >> 29) & 0x1) == 0)
12241                        {
12242                          /* 33222222222211111111110000000000
12243                             10987654321098765432109876543210
12244                             xxxxxxxxxxxxxxxxxxxxxxxx001110xx
12245                             ldr.  */
12246                          return 956;
12247                        }
12248                      else
12249                        {
12250                          if (((word >> 10) & 0x1) == 0)
12251                            {
12252                              if (((word >> 11) & 0x1) == 0)
12253                                {
12254                                  if (((word >> 22) & 0x1) == 0)
12255                                    {
12256                                      /* 33222222222211111111110000000000
12257                                         10987654321098765432109876543210
12258                                         xxxxxxxxxx00xxxxxxxxxx0x001111xx
12259                                         stur.  */
12260                                      return 899;
12261                                    }
12262                                  else
12263                                    {
12264                                      /* 33222222222211111111110000000000
12265                                         10987654321098765432109876543210
12266                                         xxxxxxxxxx00xxxxxxxxxx1x001111xx
12267                                         ldur.  */
12268                                      return 900;
12269                                    }
12270                                }
12271                              else
12272                                {
12273                                  if (((word >> 22) & 0x1) == 0)
12274                                    {
12275                                      /* 33222222222211111111110000000000
12276                                         10987654321098765432109876543210
12277                                         xxxxxxxxxx01xxxxxxxxxx0x001111xx
12278                                         str.  */
12279                                      return 878;
12280                                    }
12281                                  else
12282                                    {
12283                                      /* 33222222222211111111110000000000
12284                                         10987654321098765432109876543210
12285                                         xxxxxxxxxx01xxxxxxxxxx1x001111xx
12286                                         ldr.  */
12287                                      return 879;
12288                                    }
12289                                }
12290                            }
12291                          else
12292                            {
12293                              if (((word >> 22) & 0x1) == 0)
12294                                {
12295                                  /* 33222222222211111111110000000000
12296                                     10987654321098765432109876543210
12297                                     xxxxxxxxxx1xxxxxxxxxxx0x001111xx
12298                                     str.  */
12299                                  return 855;
12300                                }
12301                              else
12302                                {
12303                                  /* 33222222222211111111110000000000
12304                                     10987654321098765432109876543210
12305                                     xxxxxxxxxx1xxxxxxxxxxx1x001111xx
12306                                     ldr.  */
12307                                  return 856;
12308                                }
12309                            }
12310                        }
12311                    }
12312                  else
12313                    {
12314                      if (((word >> 22) & 0x1) == 0)
12315                        {
12316                          /* 33222222222211111111110000000000
12317                             10987654321098765432109876543210
12318                             xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
12319                             str.  */
12320                          return 866;
12321                        }
12322                      else
12323                        {
12324                          /* 33222222222211111111110000000000
12325                             10987654321098765432109876543210
12326                             xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
12327                             ldr.  */
12328                          return 867;
12329                        }
12330                    }
12331                }
12332            }
12333          else
12334            {
12335              if (((word >> 24) & 0x1) == 0)
12336                {
12337                  if (((word >> 21) & 0x1) == 0)
12338                    {
12339                      if (((word >> 28) & 0x1) == 0)
12340                        {
12341                          if (((word >> 10) & 0x1) == 0)
12342                            {
12343                              if (((word >> 29) & 0x1) == 0)
12344                                {
12345                                  if (((word >> 11) & 0x1) == 0)
12346                                    {
12347                                      if (((word >> 12) & 0x1) == 0)
12348                                        {
12349                                          /* 33222222222211111111110000000000
12350                                             10987654321098765432109876543210
12351                                             xxxxxxxxxx000xxxxxxxx0xx011100xx
12352                                             tbl.  */
12353                                          return 414;
12354                                        }
12355                                      else
12356                                        {
12357                                          /* 33222222222211111111110000000000
12358                                             10987654321098765432109876543210
12359                                             xxxxxxxxxx001xxxxxxxx0xx011100xx
12360                                             tbx.  */
12361                                          return 415;
12362                                        }
12363                                    }
12364                                  else
12365                                    {
12366                                      if (((word >> 12) & 0x1) == 0)
12367                                        {
12368                                          if (((word >> 14) & 0x1) == 0)
12369                                            {
12370                                              /* 33222222222211111111110000000000
12371                                                 10987654321098765432109876543210
12372                                                 xxxxxxxxxx010x0xxxxxx0xx011100xx
12373                                                 trn1.  */
12374                                              return 257;
12375                                            }
12376                                          else
12377                                            {
12378                                              /* 33222222222211111111110000000000
12379                                                 10987654321098765432109876543210
12380                                                 xxxxxxxxxx010x1xxxxxx0xx011100xx
12381                                                 trn2.  */
12382                                              return 260;
12383                                            }
12384                                        }
12385                                      else
12386                                        {
12387                                          if (((word >> 13) & 0x1) == 0)
12388                                            {
12389                                              if (((word >> 14) & 0x1) == 0)
12390                                                {
12391                                                  /* 33222222222211111111110000000000
12392                                                     10987654321098765432109876543210
12393                                                     xxxxxxxxxx01100xxxxxx0xx011100xx
12394                                                     uzp1.  */
12395                                                  return 256;
12396                                                }
12397                                              else
12398                                                {
12399                                                  /* 33222222222211111111110000000000
12400                                                     10987654321098765432109876543210
12401                                                     xxxxxxxxxx01101xxxxxx0xx011100xx
12402                                                     uzp2.  */
12403                                                  return 259;
12404                                                }
12405                                            }
12406                                          else
12407                                            {
12408                                              if (((word >> 14) & 0x1) == 0)
12409                                                {
12410                                                  /* 33222222222211111111110000000000
12411                                                     10987654321098765432109876543210
12412                                                     xxxxxxxxxx01110xxxxxx0xx011100xx
12413                                                     zip1.  */
12414                                                  return 258;
12415                                                }
12416                                              else
12417                                                {
12418                                                  /* 33222222222211111111110000000000
12419                                                     10987654321098765432109876543210
12420                                                     xxxxxxxxxx01111xxxxxx0xx011100xx
12421                                                     zip2.  */
12422                                                  return 261;
12423                                                }
12424                                            }
12425                                        }
12426                                    }
12427                                }
12428                              else
12429                                {
12430                                  /* 33222222222211111111110000000000
12431                                     10987654321098765432109876543210
12432                                     xxxxxxxxxx0xxxxxxxxxx0xx011101xx
12433                                     ext.  */
12434                                  return 130;
12435                                }
12436                            }
12437                          else
12438                            {
12439                              if (((word >> 15) & 0x1) == 0)
12440                                {
12441                                  if (((word >> 22) & 0x1) == 0)
12442                                    {
12443                                      if (((word >> 29) & 0x1) == 0)
12444                                        {
12445                                          if (((word >> 11) & 0x1) == 0)
12446                                            {
12447                                              /* 33222222222211111111110000000000
12448                                                 10987654321098765432109876543210
12449                                                 xxxxxxxxxx10xxx0xxxxx00x011100xx
12450                                                 dup.  */
12451                                              return 147;
12452                                            }
12453                                          else
12454                                            {
12455                                              if (((word >> 12) & 0x1) == 0)
12456                                                {
12457                                                  if (((word >> 13) & 0x1) == 0)
12458                                                    {
12459                                                      /* 33222222222211111111110000000000
12460                                                         10987654321098765432109876543210
12461                                                         xxxxxxxxxx1100x0xxxxx00x011100xx
12462                                                         dup.  */
12463                                                      return 148;
12464                                                    }
12465                                                  else
12466                                                    {
12467                                                      /* 33222222222211111111110000000000
12468                                                         10987654321098765432109876543210
12469                                                         xxxxxxxxxx1101x0xxxxx00x011100xx
12470                                                         smov.  */
12471                                                      return 149;
12472                                                    }
12473                                                }
12474                                              else
12475                                                {
12476                                                  if (((word >> 13) & 0x1) == 0)
12477                                                    {
12478                                                      /* 33222222222211111111110000000000
12479                                                         10987654321098765432109876543210
12480                                                         xxxxxxxxxx1110x0xxxxx00x011100xx
12481                                                         ins.  */
12482                                                      return 152;
12483                                                    }
12484                                                  else
12485                                                    {
12486                                                      /* 33222222222211111111110000000000
12487                                                         10987654321098765432109876543210
12488                                                         xxxxxxxxxx1111x0xxxxx00x011100xx
12489                                                         umov.  */
12490                                                      return 150;
12491                                                    }
12492                                                }
12493                                            }
12494                                        }
12495                                      else
12496                                        {
12497                                          /* 33222222222211111111110000000000
12498                                             10987654321098765432109876543210
12499                                             xxxxxxxxxx1xxxx0xxxxx00x011101xx
12500                                             ins.  */
12501                                          return 154;
12502                                        }
12503                                    }
12504                                  else
12505                                    {
12506                                      if (((word >> 11) & 0x1) == 0)
12507                                        {
12508                                          if (((word >> 12) & 0x1) == 0)
12509                                            {
12510                                              if (((word >> 13) & 0x1) == 0)
12511                                                {
12512                                                  if (((word >> 23) & 0x1) == 0)
12513                                                    {
12514                                                      if (((word >> 29) & 0x1) == 0)
12515                                                        {
12516                                                          /* 33222222222211111111110000000000
12517                                                             10987654321098765432109876543210
12518                                                             xxxxxxxxxx1000x0xxxxx010011100xx
12519                                                             fmaxnm.  */
12520                                                          return 286;
12521                                                        }
12522                                                      else
12523                                                        {
12524                                                          /* 33222222222211111111110000000000
12525                                                             10987654321098765432109876543210
12526                                                             xxxxxxxxxx1000x0xxxxx010011101xx
12527                                                             fmaxnmp.  */
12528                                                          return 337;
12529                                                        }
12530                                                    }
12531                                                  else
12532                                                    {
12533                                                      if (((word >> 29) & 0x1) == 0)
12534                                                        {
12535                                                          /* 33222222222211111111110000000000
12536                                                             10987654321098765432109876543210
12537                                                             xxxxxxxxxx1000x0xxxxx011011100xx
12538                                                             fminnm.  */
12539                                                          return 302;
12540                                                        }
12541                                                      else
12542                                                        {
12543                                                          /* 33222222222211111111110000000000
12544                                                             10987654321098765432109876543210
12545                                                             xxxxxxxxxx1000x0xxxxx011011101xx
12546                                                             fminnmp.  */
12547                                                          return 353;
12548                                                        }
12549                                                    }
12550                                                }
12551                                              else
12552                                                {
12553                                                  if (((word >> 23) & 0x1) == 0)
12554                                                    {
12555                                                      if (((word >> 29) & 0x1) == 0)
12556                                                        {
12557                                                          /* 33222222222211111111110000000000
12558                                                             10987654321098765432109876543210
12559                                                             xxxxxxxxxx1001x0xxxxx010011100xx
12560                                                             fcmeq.  */
12561                                                          return 294;
12562                                                        }
12563                                                      else
12564                                                        {
12565                                                          /* 33222222222211111111110000000000
12566                                                             10987654321098765432109876543210
12567                                                             xxxxxxxxxx1001x0xxxxx010011101xx
12568                                                             fcmge.  */
12569                                                          return 343;
12570                                                        }
12571                                                    }
12572                                                  else
12573                                                    {
12574                                                      /* 33222222222211111111110000000000
12575                                                         10987654321098765432109876543210
12576                                                         xxxxxxxxxx1001x0xxxxx01101110xxx
12577                                                         fcmgt.  */
12578                                                      return 357;
12579                                                    }
12580                                                }
12581                                            }
12582                                          else
12583                                            {
12584                                              if (((word >> 13) & 0x1) == 0)
12585                                                {
12586                                                  if (((word >> 23) & 0x1) == 0)
12587                                                    {
12588                                                      if (((word >> 29) & 0x1) == 0)
12589                                                        {
12590                                                          /* 33222222222211111111110000000000
12591                                                             10987654321098765432109876543210
12592                                                             xxxxxxxxxx1010x0xxxxx010011100xx
12593                                                             fadd.  */
12594                                                          return 290;
12595                                                        }
12596                                                      else
12597                                                        {
12598                                                          /* 33222222222211111111110000000000
12599                                                             10987654321098765432109876543210
12600                                                             xxxxxxxxxx1010x0xxxxx010011101xx
12601                                                             faddp.  */
12602                                                          return 339;
12603                                                        }
12604                                                    }
12605                                                  else
12606                                                    {
12607                                                      if (((word >> 29) & 0x1) == 0)
12608                                                        {
12609                                                          /* 33222222222211111111110000000000
12610                                                             10987654321098765432109876543210
12611                                                             xxxxxxxxxx1010x0xxxxx011011100xx
12612                                                             fsub.  */
12613                                                          return 306;
12614                                                        }
12615                                                      else
12616                                                        {
12617                                                          /* 33222222222211111111110000000000
12618                                                             10987654321098765432109876543210
12619                                                             xxxxxxxxxx1010x0xxxxx011011101xx
12620                                                             fabd.  */
12621                                                          return 355;
12622                                                        }
12623                                                    }
12624                                                }
12625                                              else
12626                                                {
12627                                                  if (((word >> 23) & 0x1) == 0)
12628                                                    {
12629                                                      if (((word >> 29) & 0x1) == 0)
12630                                                        {
12631                                                          /* 33222222222211111111110000000000
12632                                                             10987654321098765432109876543210
12633                                                             xxxxxxxxxx1011x0xxxxx010011100xx
12634                                                             fmax.  */
12635                                                          return 296;
12636                                                        }
12637                                                      else
12638                                                        {
12639                                                          /* 33222222222211111111110000000000
12640                                                             10987654321098765432109876543210
12641                                                             xxxxxxxxxx1011x0xxxxx010011101xx
12642                                                             fmaxp.  */
12643                                                          return 347;
12644                                                        }
12645                                                    }
12646                                                  else
12647                                                    {
12648                                                      if (((word >> 29) & 0x1) == 0)
12649                                                        {
12650                                                          /* 33222222222211111111110000000000
12651                                                             10987654321098765432109876543210
12652                                                             xxxxxxxxxx1011x0xxxxx011011100xx
12653                                                             fmin.  */
12654                                                          return 308;
12655                                                        }
12656                                                      else
12657                                                        {
12658                                                          /* 33222222222211111111110000000000
12659                                                             10987654321098765432109876543210
12660                                                             xxxxxxxxxx1011x0xxxxx011011101xx
12661                                                             fminp.  */
12662                                                          return 361;
12663                                                        }
12664                                                    }
12665                                                }
12666                                            }
12667                                        }
12668                                      else
12669                                        {
12670                                          if (((word >> 12) & 0x1) == 0)
12671                                            {
12672                                              if (((word >> 13) & 0x1) == 0)
12673                                                {
12674                                                  if (((word >> 23) & 0x1) == 0)
12675                                                    {
12676                                                      /* 33222222222211111111110000000000
12677                                                         10987654321098765432109876543210
12678                                                         xxxxxxxxxx1100x0xxxxx01001110xxx
12679                                                         fmla.  */
12680                                                      return 288;
12681                                                    }
12682                                                  else
12683                                                    {
12684                                                      /* 33222222222211111111110000000000
12685                                                         10987654321098765432109876543210
12686                                                         xxxxxxxxxx1100x0xxxxx01101110xxx
12687                                                         fmls.  */
12688                                                      return 304;
12689                                                    }
12690                                                }
12691                                              else
12692                                                {
12693                                                  if (((word >> 23) & 0x1) == 0)
12694                                                    {
12695                                                      /* 33222222222211111111110000000000
12696                                                         10987654321098765432109876543210
12697                                                         xxxxxxxxxx1101x0xxxxx01001110xxx
12698                                                         facge.  */
12699                                                      return 345;
12700                                                    }
12701                                                  else
12702                                                    {
12703                                                      /* 33222222222211111111110000000000
12704                                                         10987654321098765432109876543210
12705                                                         xxxxxxxxxx1101x0xxxxx01101110xxx
12706                                                         facgt.  */
12707                                                      return 359;
12708                                                    }
12709                                                }
12710                                            }
12711                                          else
12712                                            {
12713                                              if (((word >> 13) & 0x1) == 0)
12714                                                {
12715                                                  if (((word >> 29) & 0x1) == 0)
12716                                                    {
12717                                                      /* 33222222222211111111110000000000
12718                                                         10987654321098765432109876543210
12719                                                         xxxxxxxxxx1110x0xxxxx01x011100xx
12720                                                         fmulx.  */
12721                                                      return 292;
12722                                                    }
12723                                                  else
12724                                                    {
12725                                                      /* 33222222222211111111110000000000
12726                                                         10987654321098765432109876543210
12727                                                         xxxxxxxxxx1110x0xxxxx01x011101xx
12728                                                         fmul.  */
12729                                                      return 341;
12730                                                    }
12731                                                }
12732                                              else
12733                                                {
12734                                                  if (((word >> 23) & 0x1) == 0)
12735                                                    {
12736                                                      if (((word >> 29) & 0x1) == 0)
12737                                                        {
12738                                                          /* 33222222222211111111110000000000
12739                                                             10987654321098765432109876543210
12740                                                             xxxxxxxxxx1111x0xxxxx010011100xx
12741                                                             frecps.  */
12742                                                          return 298;
12743                                                        }
12744                                                      else
12745                                                        {
12746                                                          /* 33222222222211111111110000000000
12747                                                             10987654321098765432109876543210
12748                                                             xxxxxxxxxx1111x0xxxxx010011101xx
12749                                                             fdiv.  */
12750                                                          return 349;
12751                                                        }
12752                                                    }
12753                                                  else
12754                                                    {
12755                                                      /* 33222222222211111111110000000000
12756                                                         10987654321098765432109876543210
12757                                                         xxxxxxxxxx1111x0xxxxx01101110xxx
12758                                                         frsqrts.  */
12759                                                      return 310;
12760                                                    }
12761                                                }
12762                                            }
12763                                        }
12764                                    }
12765                                }
12766                              else
12767                                {
12768                                  if (((word >> 13) & 0x1) == 0)
12769                                    {
12770                                      if (((word >> 14) & 0x1) == 0)
12771                                        {
12772                                          if (((word >> 11) & 0x1) == 0)
12773                                            {
12774                                              /* 33222222222211111111110000000000
12775                                                 10987654321098765432109876543210
12776                                                 xxxxxxxxxx10x001xxxxx0xx01110xxx
12777                                                 sqrdmlah.  */
12778                                              return 364;
12779                                            }
12780                                          else
12781                                            {
12782                                              /* 33222222222211111111110000000000
12783                                                 10987654321098765432109876543210
12784                                                 xxxxxxxxxx11x001xxxxx0xx01110xxx
12785                                                 sqrdmlsh.  */
12786                                              return 365;
12787                                            }
12788                                        }
12789                                      else
12790                                        {
12791                                          /* 33222222222211111111110000000000
12792                                             10987654321098765432109876543210
12793                                             xxxxxxxxxx1xx011xxxxx0xx01110xxx
12794                                             fcmla.  */
12795                                          return 366;
12796                                        }
12797                                    }
12798                                  else
12799                                    {
12800                                      /* 33222222222211111111110000000000
12801                                         10987654321098765432109876543210
12802                                         xxxxxxxxxx1xx1x1xxxxx0xx01110xxx
12803                                         fcadd.  */
12804                                      return 367;
12805                                    }
12806                                }
12807                            }
12808                        }
12809                      else
12810                        {
12811                          if (((word >> 29) & 0x1) == 0)
12812                            {
12813                              if (((word >> 30) & 0x1) == 0)
12814                                {
12815                                  if (((word >> 16) & 0x1) == 0)
12816                                    {
12817                                      if (((word >> 17) & 0x1) == 0)
12818                                        {
12819                                          /* 33222222222211111111110000000000
12820                                             10987654321098765432109876543210
12821                                             xxxxxxxxxxxxxxxx00xxx0xx0111100x
12822                                             fcvtzs.  */
12823                                          return 752;
12824                                        }
12825                                      else
12826                                        {
12827                                          /* 33222222222211111111110000000000
12828                                             10987654321098765432109876543210
12829                                             xxxxxxxxxxxxxxxx01xxx0xx0111100x
12830                                             scvtf.  */
12831                                          return 748;
12832                                        }
12833                                    }
12834                                  else
12835                                    {
12836                                      if (((word >> 17) & 0x1) == 0)
12837                                        {
12838                                          /* 33222222222211111111110000000000
12839                                             10987654321098765432109876543210
12840                                             xxxxxxxxxxxxxxxx10xxx0xx0111100x
12841                                             fcvtzu.  */
12842                                          return 754;
12843                                        }
12844                                      else
12845                                        {
12846                                          /* 33222222222211111111110000000000
12847                                             10987654321098765432109876543210
12848                                             xxxxxxxxxxxxxxxx11xxx0xx0111100x
12849                                             ucvtf.  */
12850                                          return 750;
12851                                        }
12852                                    }
12853                                }
12854                              else
12855                                {
12856                                  if (((word >> 10) & 0x1) == 0)
12857                                    {
12858                                      if (((word >> 12) & 0x1) == 0)
12859                                        {
12860                                          if (((word >> 13) & 0x1) == 0)
12861                                            {
12862                                              if (((word >> 14) & 0x1) == 0)
12863                                                {
12864                                                  /* 33222222222211111111110000000000
12865                                                     10987654321098765432109876543210
12866                                                     xxxxxxxxxx0x000xxxxxx0xx0111101x
12867                                                     sha1c.  */
12868                                                  return 672;
12869                                                }
12870                                              else
12871                                                {
12872                                                  /* 33222222222211111111110000000000
12873                                                     10987654321098765432109876543210
12874                                                     xxxxxxxxxx0x001xxxxxx0xx0111101x
12875                                                     sha256h.  */
12876                                                  return 676;
12877                                                }
12878                                            }
12879                                          else
12880                                            {
12881                                              if (((word >> 14) & 0x1) == 0)
12882                                                {
12883                                                  /* 33222222222211111111110000000000
12884                                                     10987654321098765432109876543210
12885                                                     xxxxxxxxxx0x010xxxxxx0xx0111101x
12886                                                     sha1m.  */
12887                                                  return 674;
12888                                                }
12889                                              else
12890                                                {
12891                                                  /* 33222222222211111111110000000000
12892                                                     10987654321098765432109876543210
12893                                                     xxxxxxxxxx0x011xxxxxx0xx0111101x
12894                                                     sha256su1.  */
12895                                                  return 678;
12896                                                }
12897                                            }
12898                                        }
12899                                      else
12900                                        {
12901                                          if (((word >> 13) & 0x1) == 0)
12902                                            {
12903                                              if (((word >> 14) & 0x1) == 0)
12904                                                {
12905                                                  /* 33222222222211111111110000000000
12906                                                     10987654321098765432109876543210
12907                                                     xxxxxxxxxx0x100xxxxxx0xx0111101x
12908                                                     sha1p.  */
12909                                                  return 673;
12910                                                }
12911                                              else
12912                                                {
12913                                                  /* 33222222222211111111110000000000
12914                                                     10987654321098765432109876543210
12915                                                     xxxxxxxxxx0x101xxxxxx0xx0111101x
12916                                                     sha256h2.  */
12917                                                  return 677;
12918                                                }
12919                                            }
12920                                          else
12921                                            {
12922                                              /* 33222222222211111111110000000000
12923                                                 10987654321098765432109876543210
12924                                                 xxxxxxxxxx0x11xxxxxxx0xx0111101x
12925                                                 sha1su0.  */
12926                                              return 675;
12927                                            }
12928                                        }
12929                                    }
12930                                  else
12931                                    {
12932                                      if (((word >> 11) & 0x1) == 0)
12933                                        {
12934                                          if (((word >> 13) & 0x1) == 0)
12935                                            {
12936                                              /* 33222222222211111111110000000000
12937                                                 10987654321098765432109876543210
12938                                                 xxxxxxxxxx10x0xxxxxxx0xx0111101x
12939                                                 dup.  */
12940                                              return 529;
12941                                            }
12942                                          else
12943                                            {
12944                                              /* 33222222222211111111110000000000
12945                                                 10987654321098765432109876543210
12946                                                 xxxxxxxxxx10x1xxxxxxx0xx0111101x
12947                                                 fcmeq.  */
12948                                              return 550;
12949                                            }
12950                                        }
12951                                      else
12952                                        {
12953                                          if (((word >> 13) & 0x1) == 0)
12954                                            {
12955                                              /* 33222222222211111111110000000000
12956                                                 10987654321098765432109876543210
12957                                                 xxxxxxxxxx11x0xxxxxxx0xx0111101x
12958                                                 fmulx.  */
12959                                              return 548;
12960                                            }
12961                                          else
12962                                            {
12963                                              if (((word >> 23) & 0x1) == 0)
12964                                                {
12965                                                  /* 33222222222211111111110000000000
12966                                                     10987654321098765432109876543210
12967                                                     xxxxxxxxxx11x1xxxxxxx0x00111101x
12968                                                     frecps.  */
12969                                                  return 552;
12970                                                }
12971                                              else
12972                                                {
12973                                                  /* 33222222222211111111110000000000
12974                                                     10987654321098765432109876543210
12975                                                     xxxxxxxxxx11x1xxxxxxx0x10111101x
12976                                                     frsqrts.  */
12977                                                  return 554;
12978                                                }
12979                                            }
12980                                        }
12981                                    }
12982                                }
12983                            }
12984                          else
12985                            {
12986                              if (((word >> 11) & 0x1) == 0)
12987                                {
12988                                  if (((word >> 12) & 0x1) == 0)
12989                                    {
12990                                      if (((word >> 13) & 0x1) == 0)
12991                                        {
12992                                          /* 33222222222211111111110000000000
12993                                             10987654321098765432109876543210
12994                                             xxxxxxxxxxx000xxxxxxx0xx011111xx
12995                                             sqrdmlah.  */
12996                                          return 582;
12997                                        }
12998                                      else
12999                                        {
13000                                          if (((word >> 23) & 0x1) == 0)
13001                                            {
13002                                              /* 33222222222211111111110000000000
13003                                                 10987654321098765432109876543210
13004                                                 xxxxxxxxxxx001xxxxxxx0x0011111xx
13005                                                 fcmge.  */
13006                                              return 567;
13007                                            }
13008                                          else
13009                                            {
13010                                              /* 33222222222211111111110000000000
13011                                                 10987654321098765432109876543210
13012                                                 xxxxxxxxxxx001xxxxxxx0x1011111xx
13013                                                 fcmgt.  */
13014                                              return 573;
13015                                            }
13016                                        }
13017                                    }
13018                                  else
13019                                    {
13020                                      /* 33222222222211111111110000000000
13021                                         10987654321098765432109876543210
13022                                         xxxxxxxxxxx01xxxxxxxx0xx011111xx
13023                                         fabd.  */
13024                                      return 571;
13025                                    }
13026                                }
13027                              else
13028                                {
13029                                  if (((word >> 13) & 0x1) == 0)
13030                                    {
13031                                      /* 33222222222211111111110000000000
13032                                         10987654321098765432109876543210
13033                                         xxxxxxxxxxx1x0xxxxxxx0xx011111xx
13034                                         sqrdmlsh.  */
13035                                      return 583;
13036                                    }
13037                                  else
13038                                    {
13039                                      if (((word >> 23) & 0x1) == 0)
13040                                        {
13041                                          /* 33222222222211111111110000000000
13042                                             10987654321098765432109876543210
13043                                             xxxxxxxxxxx1x1xxxxxxx0x0011111xx
13044                                             facge.  */
13045                                          return 569;
13046                                        }
13047                                      else
13048                                        {
13049                                          /* 33222222222211111111110000000000
13050                                             10987654321098765432109876543210
13051                                             xxxxxxxxxxx1x1xxxxxxx0x1011111xx
13052                                             facgt.  */
13053                                          return 575;
13054                                        }
13055                                    }
13056                                }
13057                            }
13058                        }
13059                    }
13060                  else
13061                    {
13062                      if (((word >> 10) & 0x1) == 0)
13063                        {
13064                          if (((word >> 11) & 0x1) == 0)
13065                            {
13066                              if (((word >> 12) & 0x1) == 0)
13067                                {
13068                                  if (((word >> 13) & 0x1) == 0)
13069                                    {
13070                                      if (((word >> 14) & 0x1) == 0)
13071                                        {
13072                                          if (((word >> 15) & 0x1) == 0)
13073                                            {
13074                                              if (((word >> 28) & 0x1) == 0)
13075                                                {
13076                                                  if (((word >> 29) & 0x1) == 0)
13077                                                    {
13078                                                      if (((word >> 30) & 0x1) == 0)
13079                                                        {
13080                                                          /* 33222222222211111111110000000000
13081                                                             10987654321098765432109876543210
13082                                                             xxxxxxxxxx000000xxxxx1xx0111000x
13083                                                             saddl.  */
13084                                                          return 42;
13085                                                        }
13086                                                      else
13087                                                        {
13088                                                          /* 33222222222211111111110000000000
13089                                                             10987654321098765432109876543210
13090                                                             xxxxxxxxxx000000xxxxx1xx0111001x
13091                                                             saddl2.  */
13092                                                          return 43;
13093                                                        }
13094                                                    }
13095                                                  else
13096                                                    {
13097                                                      if (((word >> 30) & 0x1) == 0)
13098                                                        {
13099                                                          /* 33222222222211111111110000000000
13100                                                             10987654321098765432109876543210
13101                                                             xxxxxxxxxx000000xxxxx1xx0111010x
13102                                                             uaddl.  */
13103                                                          return 74;
13104                                                        }
13105                                                      else
13106                                                        {
13107                                                          /* 33222222222211111111110000000000
13108                                                             10987654321098765432109876543210
13109                                                             xxxxxxxxxx000000xxxxx1xx0111011x
13110                                                             uaddl2.  */
13111                                                          return 75;
13112                                                        }
13113                                                    }
13114                                                }
13115                                              else
13116                                                {
13117                                                  if (((word >> 16) & 0x1) == 0)
13118                                                    {
13119                                                      if (((word >> 17) & 0x1) == 0)
13120                                                        {
13121                                                          if (((word >> 18) & 0x1) == 0)
13122                                                            {
13123                                                              if (((word >> 19) & 0x1) == 0)
13124                                                                {
13125                                                                  if (((word >> 20) & 0x1) == 0)
13126                                                                    {
13127                                                                      /* 33222222222211111111110000000000
13128                                                                         10987654321098765432109876543210
13129                                                                         xxxxxxxxxx000000000001xx01111xxx
13130                                                                         fcvtns.  */
13131                                                                      return 756;
13132                                                                    }
13133                                                                  else
13134                                                                    {
13135                                                                      /* 33222222222211111111110000000000
13136                                                                         10987654321098765432109876543210
13137                                                                         xxxxxxxxxx000000000011xx01111xxx
13138                                                                         fcvtms.  */
13139                                                                      return 776;
13140                                                                    }
13141                                                                }
13142                                                              else
13143                                                                {
13144                                                                  if (((word >> 20) & 0x1) == 0)
13145                                                                    {
13146                                                                      /* 33222222222211111111110000000000
13147                                                                         10987654321098765432109876543210
13148                                                                         xxxxxxxxxx000000000101xx01111xxx
13149                                                                         fcvtps.  */
13150                                                                      return 772;
13151                                                                    }
13152                                                                  else
13153                                                                    {
13154                                                                      /* 33222222222211111111110000000000
13155                                                                         10987654321098765432109876543210
13156                                                                         xxxxxxxxxx000000000111xx01111xxx
13157                                                                         fcvtzs.  */
13158                                                                      return 780;
13159                                                                    }
13160                                                                }
13161                                                            }
13162                                                          else
13163                                                            {
13164                                                              /* 33222222222211111111110000000000
13165                                                                 10987654321098765432109876543210
13166                                                                 xxxxxxxxxx000000001xx1xx01111xxx
13167                                                                 fcvtas.  */
13168                                                              return 764;
13169                                                            }
13170                                                        }
13171                                                      else
13172                                                        {
13173                                                          if (((word >> 18) & 0x1) == 0)
13174                                                            {
13175                                                              /* 33222222222211111111110000000000
13176                                                                 10987654321098765432109876543210
13177                                                                 xxxxxxxxxx000000010xx1xx01111xxx
13178                                                                 scvtf.  */
13179                                                              return 760;
13180                                                            }
13181                                                          else
13182                                                            {
13183                                                              if (((word >> 19) & 0x1) == 0)
13184                                                                {
13185                                                                  /* 33222222222211111111110000000000
13186                                                                     10987654321098765432109876543210
13187                                                                     xxxxxxxxxx0000000110x1xx01111xxx
13188                                                                     fmov.  */
13189                                                                  return 768;
13190                                                                }
13191                                                              else
13192                                                                {
13193                                                                  if (((word >> 20) & 0x1) == 0)
13194                                                                    {
13195                                                                      /* 33222222222211111111110000000000
13196                                                                         10987654321098765432109876543210
13197                                                                         xxxxxxxxxx000000011101xx01111xxx
13198                                                                         fmov.  */
13199                                                                      return 784;
13200                                                                    }
13201                                                                  else
13202                                                                    {
13203                                                                      /* 33222222222211111111110000000000
13204                                                                         10987654321098765432109876543210
13205                                                                         xxxxxxxxxx000000011111xx01111xxx
13206                                                                         fjcvtzs.  */
13207                                                                      return 786;
13208                                                                    }
13209                                                                }
13210                                                            }
13211                                                        }
13212                                                    }
13213                                                  else
13214                                                    {
13215                                                      if (((word >> 17) & 0x1) == 0)
13216                                                        {
13217                                                          if (((word >> 18) & 0x1) == 0)
13218                                                            {
13219                                                              if (((word >> 19) & 0x1) == 0)
13220                                                                {
13221                                                                  if (((word >> 20) & 0x1) == 0)
13222                                                                    {
13223                                                                      /* 33222222222211111111110000000000
13224                                                                         10987654321098765432109876543210
13225                                                                         xxxxxxxxxx000000100001xx01111xxx
13226                                                                         fcvtnu.  */
13227                                                                      return 758;
13228                                                                    }
13229                                                                  else
13230                                                                    {
13231                                                                      /* 33222222222211111111110000000000
13232                                                                         10987654321098765432109876543210
13233                                                                         xxxxxxxxxx000000100011xx01111xxx
13234                                                                         fcvtmu.  */
13235                                                                      return 778;
13236                                                                    }
13237                                                                }
13238                                                              else
13239                                                                {
13240                                                                  if (((word >> 20) & 0x1) == 0)
13241                                                                    {
13242                                                                      /* 33222222222211111111110000000000
13243                                                                         10987654321098765432109876543210
13244                                                                         xxxxxxxxxx000000100101xx01111xxx
13245                                                                         fcvtpu.  */
13246                                                                      return 774;
13247                                                                    }
13248                                                                  else
13249                                                                    {
13250                                                                      /* 33222222222211111111110000000000
13251                                                                         10987654321098765432109876543210
13252                                                                         xxxxxxxxxx000000100111xx01111xxx
13253                                                                         fcvtzu.  */
13254                                                                      return 782;
13255                                                                    }
13256                                                                }
13257                                                            }
13258                                                          else
13259                                                            {
13260                                                              /* 33222222222211111111110000000000
13261                                                                 10987654321098765432109876543210
13262                                                                 xxxxxxxxxx000000101xx1xx01111xxx
13263                                                                 fcvtau.  */
13264                                                              return 766;
13265                                                            }
13266                                                        }
13267                                                      else
13268                                                        {
13269                                                          if (((word >> 18) & 0x1) == 0)
13270                                                            {
13271                                                              /* 33222222222211111111110000000000
13272                                                                 10987654321098765432109876543210
13273                                                                 xxxxxxxxxx000000110xx1xx01111xxx
13274                                                                 ucvtf.  */
13275                                                              return 762;
13276                                                            }
13277                                                          else
13278                                                            {
13279                                                              if (((word >> 19) & 0x1) == 0)
13280                                                                {
13281                                                                  /* 33222222222211111111110000000000
13282                                                                     10987654321098765432109876543210
13283                                                                     xxxxxxxxxx0000001110x1xx01111xxx
13284                                                                     fmov.  */
13285                                                                  return 770;
13286                                                                }
13287                                                              else
13288                                                                {
13289                                                                  /* 33222222222211111111110000000000
13290                                                                     10987654321098765432109876543210
13291                                                                     xxxxxxxxxx0000001111x1xx01111xxx
13292                                                                     fmov.  */
13293                                                                  return 785;
13294                                                                }
13295                                                            }
13296                                                        }
13297                                                    }
13298                                                }
13299                                            }
13300                                          else
13301                                            {
13302                                              if (((word >> 29) & 0x1) == 0)
13303                                                {
13304                                                  if (((word >> 30) & 0x1) == 0)
13305                                                    {
13306                                                      /* 33222222222211111111110000000000
13307                                                         10987654321098765432109876543210
13308                                                         xxxxxxxxxx000001xxxxx1xx0111x00x
13309                                                         smlal.  */
13310                                                      return 58;
13311                                                    }
13312                                                  else
13313                                                    {
13314                                                      /* 33222222222211111111110000000000
13315                                                         10987654321098765432109876543210
13316                                                         xxxxxxxxxx000001xxxxx1xx0111x01x
13317                                                         smlal2.  */
13318                                                      return 59;
13319                                                    }
13320                                                }
13321                                              else
13322                                                {
13323                                                  if (((word >> 30) & 0x1) == 0)
13324                                                    {
13325                                                      /* 33222222222211111111110000000000
13326                                                         10987654321098765432109876543210
13327                                                         xxxxxxxxxx000001xxxxx1xx0111x10x
13328                                                         umlal.  */
13329                                                      return 90;
13330                                                    }
13331                                                  else
13332                                                    {
13333                                                      /* 33222222222211111111110000000000
13334                                                         10987654321098765432109876543210
13335                                                         xxxxxxxxxx000001xxxxx1xx0111x11x
13336                                                         umlal2.  */
13337                                                      return 91;
13338                                                    }
13339                                                }
13340                                            }
13341                                        }
13342                                      else
13343                                        {
13344                                          if (((word >> 28) & 0x1) == 0)
13345                                            {
13346                                              if (((word >> 15) & 0x1) == 0)
13347                                                {
13348                                                  if (((word >> 29) & 0x1) == 0)
13349                                                    {
13350                                                      if (((word >> 30) & 0x1) == 0)
13351                                                        {
13352                                                          /* 33222222222211111111110000000000
13353                                                             10987654321098765432109876543210
13354                                                             xxxxxxxxxx000010xxxxx1xx0111000x
13355                                                             addhn.  */
13356                                                          return 50;
13357                                                        }
13358                                                      else
13359                                                        {
13360                                                          /* 33222222222211111111110000000000
13361                                                             10987654321098765432109876543210
13362                                                             xxxxxxxxxx000010xxxxx1xx0111001x
13363                                                             addhn2.  */
13364                                                          return 51;
13365                                                        }
13366                                                    }
13367                                                  else
13368                                                    {
13369                                                      if (((word >> 30) & 0x1) == 0)
13370                                                        {
13371                                                          /* 33222222222211111111110000000000
13372                                                             10987654321098765432109876543210
13373                                                             xxxxxxxxxx000010xxxxx1xx0111010x
13374                                                             raddhn.  */
13375                                                          return 82;
13376                                                        }
13377                                                      else
13378                                                        {
13379                                                          /* 33222222222211111111110000000000
13380                                                             10987654321098765432109876543210
13381                                                             xxxxxxxxxx000010xxxxx1xx0111011x
13382                                                             raddhn2.  */
13383                                                          return 83;
13384                                                        }
13385                                                    }
13386                                                }
13387                                              else
13388                                                {
13389                                                  if (((word >> 29) & 0x1) == 0)
13390                                                    {
13391                                                      if (((word >> 30) & 0x1) == 0)
13392                                                        {
13393                                                          /* 33222222222211111111110000000000
13394                                                             10987654321098765432109876543210
13395                                                             xxxxxxxxxx000011xxxxx1xx0111000x
13396                                                             smull.  */
13397                                                          return 66;
13398                                                        }
13399                                                      else
13400                                                        {
13401                                                          /* 33222222222211111111110000000000
13402                                                             10987654321098765432109876543210
13403                                                             xxxxxxxxxx000011xxxxx1xx0111001x
13404                                                             smull2.  */
13405                                                          return 67;
13406                                                        }
13407                                                    }
13408                                                  else
13409                                                    {
13410                                                      if (((word >> 30) & 0x1) == 0)
13411                                                        {
13412                                                          /* 33222222222211111111110000000000
13413                                                             10987654321098765432109876543210
13414                                                             xxxxxxxxxx000011xxxxx1xx0111010x
13415                                                             umull.  */
13416                                                          return 94;
13417                                                        }
13418                                                      else
13419                                                        {
13420                                                          /* 33222222222211111111110000000000
13421                                                             10987654321098765432109876543210
13422                                                             xxxxxxxxxx000011xxxxx1xx0111011x
13423                                                             umull2.  */
13424                                                          return 95;
13425                                                        }
13426                                                    }
13427                                                }
13428                                            }
13429                                          else
13430                                            {
13431                                              if (((word >> 17) & 0x1) == 0)
13432                                                {
13433                                                  if (((word >> 15) & 0x1) == 0)
13434                                                    {
13435                                                      if (((word >> 16) & 0x1) == 0)
13436                                                        {
13437                                                          if (((word >> 18) & 0x1) == 0)
13438                                                            {
13439                                                              /* 33222222222211111111110000000000
13440                                                                 10987654321098765432109876543210
13441                                                                 xxxxxxxxxx000010000xx1xx01111xxx
13442                                                                 fmov.  */
13443                                                              return 799;
13444                                                            }
13445                                                          else
13446                                                            {
13447                                                              /* 33222222222211111111110000000000
13448                                                                 10987654321098765432109876543210
13449                                                                 xxxxxxxxxx000010001xx1xx01111xxx
13450                                                                 frintn.  */
13451                                                              return 808;
13452                                                            }
13453                                                        }
13454                                                      else
13455                                                        {
13456                                                          if (((word >> 18) & 0x1) == 0)
13457                                                            {
13458                                                              /* 33222222222211111111110000000000
13459                                                                 10987654321098765432109876543210
13460                                                                 xxxxxxxxxx000010100xx1xx01111xxx
13461                                                                 fneg.  */
13462                                                              return 803;
13463                                                            }
13464                                                          else
13465                                                            {
13466                                                              /* 33222222222211111111110000000000
13467                                                                 10987654321098765432109876543210
13468                                                                 xxxxxxxxxx000010101xx1xx01111xxx
13469                                                                 frintm.  */
13470                                                              return 812;
13471                                                            }
13472                                                        }
13473                                                    }
13474                                                  else
13475                                                    {
13476                                                      if (((word >> 16) & 0x1) == 0)
13477                                                        {
13478                                                          if (((word >> 18) & 0x1) == 0)
13479                                                            {
13480                                                              /* 33222222222211111111110000000000
13481                                                                 10987654321098765432109876543210
13482                                                                 xxxxxxxxxx000011000xx1xx01111xxx
13483                                                                 fabs.  */
13484                                                              return 801;
13485                                                            }
13486                                                          else
13487                                                            {
13488                                                              /* 33222222222211111111110000000000
13489                                                                 10987654321098765432109876543210
13490                                                                 xxxxxxxxxx000011001xx1xx01111xxx
13491                                                                 frintp.  */
13492                                                              return 810;
13493                                                            }
13494                                                        }
13495                                                      else
13496                                                        {
13497                                                          if (((word >> 18) & 0x1) == 0)
13498                                                            {
13499                                                              /* 33222222222211111111110000000000
13500                                                                 10987654321098765432109876543210
13501                                                                 xxxxxxxxxx000011100xx1xx01111xxx
13502                                                                 fsqrt.  */
13503                                                              return 805;
13504                                                            }
13505                                                          else
13506                                                            {
13507                                                              /* 33222222222211111111110000000000
13508                                                                 10987654321098765432109876543210
13509                                                                 xxxxxxxxxx000011101xx1xx01111xxx
13510                                                                 frintz.  */
13511                                                              return 814;
13512                                                            }
13513                                                        }
13514                                                    }
13515                                                }
13516                                              else
13517                                                {
13518                                                  if (((word >> 18) & 0x1) == 0)
13519                                                    {
13520                                                      /* 33222222222211111111110000000000
13521                                                         10987654321098765432109876543210
13522                                                         xxxxxxxxxx00001xx10xx1xx01111xxx
13523                                                         fcvt.  */
13524                                                      return 807;
13525                                                    }
13526                                                  else
13527                                                    {
13528                                                      if (((word >> 15) & 0x1) == 0)
13529                                                        {
13530                                                          if (((word >> 16) & 0x1) == 0)
13531                                                            {
13532                                                              /* 33222222222211111111110000000000
13533                                                                 10987654321098765432109876543210
13534                                                                 xxxxxxxxxx000010011xx1xx01111xxx
13535                                                                 frinta.  */
13536                                                              return 816;
13537                                                            }
13538                                                          else
13539                                                            {
13540                                                              /* 33222222222211111111110000000000
13541                                                                 10987654321098765432109876543210
13542                                                                 xxxxxxxxxx000010111xx1xx01111xxx
13543                                                                 frintx.  */
13544                                                              return 818;
13545                                                            }
13546                                                        }
13547                                                      else
13548                                                        {
13549                                                          /* 33222222222211111111110000000000
13550                                                             10987654321098765432109876543210
13551                                                             xxxxxxxxxx000011x11xx1xx01111xxx
13552                                                             frinti.  */
13553                                                          return 820;
13554                                                        }
13555                                                    }
13556                                                }
13557                                            }
13558                                        }
13559                                    }
13560                                  else
13561                                    {
13562                                      if (((word >> 14) & 0x1) == 0)
13563                                        {
13564                                          if (((word >> 15) & 0x1) == 0)
13565                                            {
13566                                              if (((word >> 28) & 0x1) == 0)
13567                                                {
13568                                                  if (((word >> 29) & 0x1) == 0)
13569                                                    {
13570                                                      if (((word >> 30) & 0x1) == 0)
13571                                                        {
13572                                                          /* 33222222222211111111110000000000
13573                                                             10987654321098765432109876543210
13574                                                             xxxxxxxxxx000100xxxxx1xx0111000x
13575                                                             ssubl.  */
13576                                                          return 46;
13577                                                        }
13578                                                      else
13579                                                        {
13580                                                          /* 33222222222211111111110000000000
13581                                                             10987654321098765432109876543210
13582                                                             xxxxxxxxxx000100xxxxx1xx0111001x
13583                                                             ssubl2.  */
13584                                                          return 47;
13585                                                        }
13586                                                    }
13587                                                  else
13588                                                    {
13589                                                      if (((word >> 30) & 0x1) == 0)
13590                                                        {
13591                                                          /* 33222222222211111111110000000000
13592                                                             10987654321098765432109876543210
13593                                                             xxxxxxxxxx000100xxxxx1xx0111010x
13594                                                             usubl.  */
13595                                                          return 78;
13596                                                        }
13597                                                      else
13598                                                        {
13599                                                          /* 33222222222211111111110000000000
13600                                                             10987654321098765432109876543210
13601                                                             xxxxxxxxxx000100xxxxx1xx0111011x
13602                                                             usubl2.  */
13603                                                          return 79;
13604                                                        }
13605                                                    }
13606                                                }
13607                                              else
13608                                                {
13609                                                  if (((word >> 3) & 0x1) == 0)
13610                                                    {
13611                                                      if (((word >> 4) & 0x1) == 0)
13612                                                        {
13613                                                          /* 33222222222211111111110000000000
13614                                                             10987654321098765432109876543210
13615                                                             xxx00xxxxx000100xxxxx1xx01111xxx
13616                                                             fcmp.  */
13617                                                          return 791;
13618                                                        }
13619                                                      else
13620                                                        {
13621                                                          /* 33222222222211111111110000000000
13622                                                             10987654321098765432109876543210
13623                                                             xxx01xxxxx000100xxxxx1xx01111xxx
13624                                                             fcmpe.  */
13625                                                          return 793;
13626                                                        }
13627                                                    }
13628                                                  else
13629                                                    {
13630                                                      if (((word >> 4) & 0x1) == 0)
13631                                                        {
13632                                                          /* 33222222222211111111110000000000
13633                                                             10987654321098765432109876543210
13634                                                             xxx10xxxxx000100xxxxx1xx01111xxx
13635                                                             fcmp.  */
13636                                                          return 795;
13637                                                        }
13638                                                      else
13639                                                        {
13640                                                          /* 33222222222211111111110000000000
13641                                                             10987654321098765432109876543210
13642                                                             xxx11xxxxx000100xxxxx1xx01111xxx
13643                                                             fcmpe.  */
13644                                                          return 797;
13645                                                        }
13646                                                    }
13647                                                }
13648                                            }
13649                                          else
13650                                            {
13651                                              if (((word >> 29) & 0x1) == 0)
13652                                                {
13653                                                  if (((word >> 30) & 0x1) == 0)
13654                                                    {
13655                                                      /* 33222222222211111111110000000000
13656                                                         10987654321098765432109876543210
13657                                                         xxxxxxxxxx000101xxxxx1xx0111x00x
13658                                                         smlsl.  */
13659                                                      return 62;
13660                                                    }
13661                                                  else
13662                                                    {
13663                                                      /* 33222222222211111111110000000000
13664                                                         10987654321098765432109876543210
13665                                                         xxxxxxxxxx000101xxxxx1xx0111x01x
13666                                                         smlsl2.  */
13667                                                      return 63;
13668                                                    }
13669                                                }
13670                                              else
13671                                                {
13672                                                  if (((word >> 30) & 0x1) == 0)
13673                                                    {
13674                                                      /* 33222222222211111111110000000000
13675                                                         10987654321098765432109876543210
13676                                                         xxxxxxxxxx000101xxxxx1xx0111x10x
13677                                                         umlsl.  */
13678                                                      return 92;
13679                                                    }
13680                                                  else
13681                                                    {
13682                                                      /* 33222222222211111111110000000000
13683                                                         10987654321098765432109876543210
13684                                                         xxxxxxxxxx000101xxxxx1xx0111x11x
13685                                                         umlsl2.  */
13686                                                      return 93;
13687                                                    }
13688                                                }
13689                                            }
13690                                        }
13691                                      else
13692                                        {
13693                                          if (((word >> 15) & 0x1) == 0)
13694                                            {
13695                                              if (((word >> 29) & 0x1) == 0)
13696                                                {
13697                                                  if (((word >> 30) & 0x1) == 0)
13698                                                    {
13699                                                      /* 33222222222211111111110000000000
13700                                                         10987654321098765432109876543210
13701                                                         xxxxxxxxxx000110xxxxx1xx0111x00x
13702                                                         subhn.  */
13703                                                      return 54;
13704                                                    }
13705                                                  else
13706                                                    {
13707                                                      /* 33222222222211111111110000000000
13708                                                         10987654321098765432109876543210
13709                                                         xxxxxxxxxx000110xxxxx1xx0111x01x
13710                                                         subhn2.  */
13711                                                      return 55;
13712                                                    }
13713                                                }
13714                                              else
13715                                                {
13716                                                  if (((word >> 30) & 0x1) == 0)
13717                                                    {
13718                                                      /* 33222222222211111111110000000000
13719                                                         10987654321098765432109876543210
13720                                                         xxxxxxxxxx000110xxxxx1xx0111x10x
13721                                                         rsubhn.  */
13722                                                      return 86;
13723                                                    }
13724                                                  else
13725                                                    {
13726                                                      /* 33222222222211111111110000000000
13727                                                         10987654321098765432109876543210
13728                                                         xxxxxxxxxx000110xxxxx1xx0111x11x
13729                                                         rsubhn2.  */
13730                                                      return 87;
13731                                                    }
13732                                                }
13733                                            }
13734                                          else
13735                                            {
13736                                              if (((word >> 22) & 0x1) == 0)
13737                                                {
13738                                                  if (((word >> 30) & 0x1) == 0)
13739                                                    {
13740                                                      /* 33222222222211111111110000000000
13741                                                         10987654321098765432109876543210
13742                                                         xxxxxxxxxx000111xxxxx10x0111xx0x
13743                                                         pmull.  */
13744                                                      return 70;
13745                                                    }
13746                                                  else
13747                                                    {
13748                                                      /* 33222222222211111111110000000000
13749                                                         10987654321098765432109876543210
13750                                                         xxxxxxxxxx000111xxxxx10x0111xx1x
13751                                                         pmull2.  */
13752                                                      return 72;
13753                                                    }
13754                                                }
13755                                              else
13756                                                {
13757                                                  if (((word >> 30) & 0x1) == 0)
13758                                                    {
13759                                                      /* 33222222222211111111110000000000
13760                                                         10987654321098765432109876543210
13761                                                         xxxxxxxxxx000111xxxxx11x0111xx0x
13762                                                         pmull.  */
13763                                                      return 71;
13764                                                    }
13765                                                  else
13766                                                    {
13767                                                      /* 33222222222211111111110000000000
13768                                                         10987654321098765432109876543210
13769                                                         xxxxxxxxxx000111xxxxx11x0111xx1x
13770                                                         pmull2.  */
13771                                                      return 73;
13772                                                    }
13773                                                }
13774                                            }
13775                                        }
13776                                    }
13777                                }
13778                              else
13779                                {
13780                                  if (((word >> 28) & 0x1) == 0)
13781                                    {
13782                                      if (((word >> 13) & 0x1) == 0)
13783                                        {
13784                                          if (((word >> 14) & 0x1) == 0)
13785                                            {
13786                                              if (((word >> 15) & 0x1) == 0)
13787                                                {
13788                                                  if (((word >> 29) & 0x1) == 0)
13789                                                    {
13790                                                      if (((word >> 30) & 0x1) == 0)
13791                                                        {
13792                                                          /* 33222222222211111111110000000000
13793                                                             10987654321098765432109876543210
13794                                                             xxxxxxxxxx001000xxxxx1xx0111000x
13795                                                             saddw.  */
13796                                                          return 44;
13797                                                        }
13798                                                      else
13799                                                        {
13800                                                          /* 33222222222211111111110000000000
13801                                                             10987654321098765432109876543210
13802                                                             xxxxxxxxxx001000xxxxx1xx0111001x
13803                                                             saddw2.  */
13804                                                          return 45;
13805                                                        }
13806                                                    }
13807                                                  else
13808                                                    {
13809                                                      if (((word >> 30) & 0x1) == 0)
13810                                                        {
13811                                                          /* 33222222222211111111110000000000
13812                                                             10987654321098765432109876543210
13813                                                             xxxxxxxxxx001000xxxxx1xx0111010x
13814                                                             uaddw.  */
13815                                                          return 76;
13816                                                        }
13817                                                      else
13818                                                        {
13819                                                          /* 33222222222211111111110000000000
13820                                                             10987654321098765432109876543210
13821                                                             xxxxxxxxxx001000xxxxx1xx0111011x
13822                                                             uaddw2.  */
13823                                                          return 77;
13824                                                        }
13825                                                    }
13826                                                }
13827                                              else
13828                                                {
13829                                                  if (((word >> 30) & 0x1) == 0)
13830                                                    {
13831                                                      /* 33222222222211111111110000000000
13832                                                         10987654321098765432109876543210
13833                                                         xxxxxxxxxx001001xxxxx1xx01110x0x
13834                                                         sqdmlal.  */
13835                                                      return 60;
13836                                                    }
13837                                                  else
13838                                                    {
13839                                                      /* 33222222222211111111110000000000
13840                                                         10987654321098765432109876543210
13841                                                         xxxxxxxxxx001001xxxxx1xx01110x1x
13842                                                         sqdmlal2.  */
13843                                                      return 61;
13844                                                    }
13845                                                }
13846                                            }
13847                                          else
13848                                            {
13849                                              if (((word >> 15) & 0x1) == 0)
13850                                                {
13851                                                  if (((word >> 29) & 0x1) == 0)
13852                                                    {
13853                                                      if (((word >> 30) & 0x1) == 0)
13854                                                        {
13855                                                          /* 33222222222211111111110000000000
13856                                                             10987654321098765432109876543210
13857                                                             xxxxxxxxxx001010xxxxx1xx0111000x
13858                                                             sabal.  */
13859                                                          return 52;
13860                                                        }
13861                                                      else
13862                                                        {
13863                                                          /* 33222222222211111111110000000000
13864                                                             10987654321098765432109876543210
13865                                                             xxxxxxxxxx001010xxxxx1xx0111001x
13866                                                             sabal2.  */
13867                                                          return 53;
13868                                                        }
13869                                                    }
13870                                                  else
13871                                                    {
13872                                                      if (((word >> 30) & 0x1) == 0)
13873                                                        {
13874                                                          /* 33222222222211111111110000000000
13875                                                             10987654321098765432109876543210
13876                                                             xxxxxxxxxx001010xxxxx1xx0111010x
13877                                                             uabal.  */
13878                                                          return 84;
13879                                                        }
13880                                                      else
13881                                                        {
13882                                                          /* 33222222222211111111110000000000
13883                                                             10987654321098765432109876543210
13884                                                             xxxxxxxxxx001010xxxxx1xx0111011x
13885                                                             uabal2.  */
13886                                                          return 85;
13887                                                        }
13888                                                    }
13889                                                }
13890                                              else
13891                                                {
13892                                                  if (((word >> 30) & 0x1) == 0)
13893                                                    {
13894                                                      /* 33222222222211111111110000000000
13895                                                         10987654321098765432109876543210
13896                                                         xxxxxxxxxx001011xxxxx1xx01110x0x
13897                                                         sqdmull.  */
13898                                                      return 68;
13899                                                    }
13900                                                  else
13901                                                    {
13902                                                      /* 33222222222211111111110000000000
13903                                                         10987654321098765432109876543210
13904                                                         xxxxxxxxxx001011xxxxx1xx01110x1x
13905                                                         sqdmull2.  */
13906                                                      return 69;
13907                                                    }
13908                                                }
13909                                            }
13910                                        }
13911                                      else
13912                                        {
13913                                          if (((word >> 14) & 0x1) == 0)
13914                                            {
13915                                              if (((word >> 15) & 0x1) == 0)
13916                                                {
13917                                                  if (((word >> 29) & 0x1) == 0)
13918                                                    {
13919                                                      if (((word >> 30) & 0x1) == 0)
13920                                                        {
13921                                                          /* 33222222222211111111110000000000
13922                                                             10987654321098765432109876543210
13923                                                             xxxxxxxxxx001100xxxxx1xx0111000x
13924                                                             ssubw.  */
13925                                                          return 48;
13926                                                        }
13927                                                      else
13928                                                        {
13929                                                          /* 33222222222211111111110000000000
13930                                                             10987654321098765432109876543210
13931                                                             xxxxxxxxxx001100xxxxx1xx0111001x
13932                                                             ssubw2.  */
13933                                                          return 49;
13934                                                        }
13935                                                    }
13936                                                  else
13937                                                    {
13938                                                      if (((word >> 30) & 0x1) == 0)
13939                                                        {
13940                                                          /* 33222222222211111111110000000000
13941                                                             10987654321098765432109876543210
13942                                                             xxxxxxxxxx001100xxxxx1xx0111010x
13943                                                             usubw.  */
13944                                                          return 80;
13945                                                        }
13946                                                      else
13947                                                        {
13948                                                          /* 33222222222211111111110000000000
13949                                                             10987654321098765432109876543210
13950                                                             xxxxxxxxxx001100xxxxx1xx0111011x
13951                                                             usubw2.  */
13952                                                          return 81;
13953                                                        }
13954                                                    }
13955                                                }
13956                                              else
13957                                                {
13958                                                  if (((word >> 30) & 0x1) == 0)
13959                                                    {
13960                                                      /* 33222222222211111111110000000000
13961                                                         10987654321098765432109876543210
13962                                                         xxxxxxxxxx001101xxxxx1xx01110x0x
13963                                                         sqdmlsl.  */
13964                                                      return 64;
13965                                                    }
13966                                                  else
13967                                                    {
13968                                                      /* 33222222222211111111110000000000
13969                                                         10987654321098765432109876543210
13970                                                         xxxxxxxxxx001101xxxxx1xx01110x1x
13971                                                         sqdmlsl2.  */
13972                                                      return 65;
13973                                                    }
13974                                                }
13975                                            }
13976                                          else
13977                                            {
13978                                              if (((word >> 29) & 0x1) == 0)
13979                                                {
13980                                                  if (((word >> 30) & 0x1) == 0)
13981                                                    {
13982                                                      /* 33222222222211111111110000000000
13983                                                         10987654321098765432109876543210
13984                                                         xxxxxxxxxx00111xxxxxx1xx0111000x
13985                                                         sabdl.  */
13986                                                      return 56;
13987                                                    }
13988                                                  else
13989                                                    {
13990                                                      /* 33222222222211111111110000000000
13991                                                         10987654321098765432109876543210
13992                                                         xxxxxxxxxx00111xxxxxx1xx0111001x
13993                                                         sabdl2.  */
13994                                                      return 57;
13995                                                    }
13996                                                }
13997                                              else
13998                                                {
13999                                                  if (((word >> 30) & 0x1) == 0)
14000                                                    {
14001                                                      /* 33222222222211111111110000000000
14002                                                         10987654321098765432109876543210
14003                                                         xxxxxxxxxx00111xxxxxx1xx0111010x
14004                                                         uabdl.  */
14005                                                      return 88;
14006                                                    }
14007                                                  else
14008                                                    {
14009                                                      /* 33222222222211111111110000000000
14010                                                         10987654321098765432109876543210
14011                                                         xxxxxxxxxx00111xxxxxx1xx0111011x
14012                                                         uabdl2.  */
14013                                                      return 89;
14014                                                    }
14015                                                }
14016                                            }
14017                                        }
14018                                    }
14019                                  else
14020                                    {
14021                                      if (((word >> 30) & 0x1) == 0)
14022                                        {
14023                                          /* 33222222222211111111110000000000
14024                                             10987654321098765432109876543210
14025                                             xxxxxxxxxx001xxxxxxxx1xx01111x0x
14026                                             fmov.  */
14027                                          return 848;
14028                                        }
14029                                      else
14030                                        {
14031                                          if (((word >> 13) & 0x1) == 0)
14032                                            {
14033                                              if (((word >> 14) & 0x1) == 0)
14034                                                {
14035                                                  /* 33222222222211111111110000000000
14036                                                     10987654321098765432109876543210
14037                                                     xxxxxxxxxx00100xxxxxx1xx01111x1x
14038                                                     sqdmlal.  */
14039                                                  return 416;
14040                                                }
14041                                              else
14042                                                {
14043                                                  /* 33222222222211111111110000000000
14044                                                     10987654321098765432109876543210
14045                                                     xxxxxxxxxx00101xxxxxx1xx01111x1x
14046                                                     sqdmull.  */
14047                                                  return 418;
14048                                                }
14049                                            }
14050                                          else
14051                                            {
14052                                              /* 33222222222211111111110000000000
14053                                                 10987654321098765432109876543210
14054                                                 xxxxxxxxxx0011xxxxxxx1xx01111x1x
14055                                                 sqdmlsl.  */
14056                                              return 417;
14057                                            }
14058                                        }
14059                                    }
14060                                }
14061                            }
14062                          else
14063                            {
14064                              if (((word >> 12) & 0x1) == 0)
14065                                {
14066                                  if (((word >> 13) & 0x1) == 0)
14067                                    {
14068                                      if (((word >> 14) & 0x1) == 0)
14069                                        {
14070                                          if (((word >> 15) & 0x1) == 0)
14071                                            {
14072                                              if (((word >> 28) & 0x1) == 0)
14073                                                {
14074                                                  if (((word >> 29) & 0x1) == 0)
14075                                                    {
14076                                                      /* 33222222222211111111110000000000
14077                                                         10987654321098765432109876543210
14078                                                         xxxxxxxxxx010000xxxxx1xx011100xx
14079                                                         rev64.  */
14080                                                      return 156;
14081                                                    }
14082                                                  else
14083                                                    {
14084                                                      /* 33222222222211111111110000000000
14085                                                         10987654321098765432109876543210
14086                                                         xxxxxxxxxx010000xxxxx1xx011101xx
14087                                                         rev32.  */
14088                                                      return 207;
14089                                                    }
14090                                                }
14091                                              else
14092                                                {
14093                                                  if (((word >> 30) & 0x1) == 0)
14094                                                    {
14095                                                      /* 33222222222211111111110000000000
14096                                                         10987654321098765432109876543210
14097                                                         xxxxxxxxxx010000xxxxx1xx01111x0x
14098                                                         fmul.  */
14099                                                      return 822;
14100                                                    }
14101                                                  else
14102                                                    {
14103                                                      /* 33222222222211111111110000000000
14104                                                         10987654321098765432109876543210
14105                                                         xxxxxxxxxx010000xxxxx1xx01111x1x
14106                                                         sha1h.  */
14107                                                      return 669;
14108                                                    }
14109                                                }
14110                                            }
14111                                          else
14112                                            {
14113                                              if (((word >> 28) & 0x1) == 0)
14114                                                {
14115                                                  if (((word >> 16) & 0x1) == 0)
14116                                                    {
14117                                                      if (((word >> 29) & 0x1) == 0)
14118                                                        {
14119                                                          /* 33222222222211111111110000000000
14120                                                             10987654321098765432109876543210
14121                                                             xxxxxxxxxx0100010xxxx1xx011100xx
14122                                                             cmgt.  */
14123                                                          return 164;
14124                                                        }
14125                                                      else
14126                                                        {
14127                                                          /* 33222222222211111111110000000000
14128                                                             10987654321098765432109876543210
14129                                                             xxxxxxxxxx0100010xxxx1xx011101xx
14130                                                             cmge.  */
14131                                                          return 213;
14132                                                        }
14133                                                    }
14134                                                  else
14135                                                    {
14136                                                      if (((word >> 19) & 0x1) == 0)
14137                                                        {
14138                                                          if (((word >> 23) & 0x1) == 0)
14139                                                            {
14140                                                              if (((word >> 29) & 0x1) == 0)
14141                                                                {
14142                                                                  /* 33222222222211111111110000000000
14143                                                                     10987654321098765432109876543210
14144                                                                     xxxxxxxxxx0100011xx0x1x0011100xx
14145                                                                     frintn.  */
14146                                                                  return 176;
14147                                                                }
14148                                                              else
14149                                                                {
14150                                                                  /* 33222222222211111111110000000000
14151                                                                     10987654321098765432109876543210
14152                                                                     xxxxxxxxxx0100011xx0x1x0011101xx
14153                                                                     frinta.  */
14154                                                                  return 224;
14155                                                                }
14156                                                            }
14157                                                          else
14158                                                            {
14159                                                              /* 33222222222211111111110000000000
14160                                                                 10987654321098765432109876543210
14161                                                                 xxxxxxxxxx0100011xx0x1x101110xxx
14162                                                                 frintp.  */
14163                                                              return 196;
14164                                                            }
14165                                                        }
14166                                                      else
14167                                                        {
14168                                                          if (((word >> 23) & 0x1) == 0)
14169                                                            {
14170                                                              if (((word >> 29) & 0x1) == 0)
14171                                                                {
14172                                                                  /* 33222222222211111111110000000000
14173                                                                     10987654321098765432109876543210
14174                                                                     xxxxxxxxxx0100011xx1x1x0011100xx
14175                                                                     frintn.  */
14176                                                                  return 177;
14177                                                                }
14178                                                              else
14179                                                                {
14180                                                                  /* 33222222222211111111110000000000
14181                                                                     10987654321098765432109876543210
14182                                                                     xxxxxxxxxx0100011xx1x1x0011101xx
14183                                                                     frinta.  */
14184                                                                  return 225;
14185                                                                }
14186                                                            }
14187                                                          else
14188                                                            {
14189                                                              /* 33222222222211111111110000000000
14190                                                                 10987654321098765432109876543210
14191                                                                 xxxxxxxxxx0100011xx1x1x101110xxx
14192                                                                 frintp.  */
14193                                                              return 197;
14194                                                            }
14195                                                        }
14196                                                    }
14197                                                }
14198                                              else
14199                                                {
14200                                                  if (((word >> 29) & 0x1) == 0)
14201                                                    {
14202                                                      if (((word >> 30) & 0x1) == 0)
14203                                                        {
14204                                                          /* 33222222222211111111110000000000
14205                                                             10987654321098765432109876543210
14206                                                             xxxxxxxxxx010001xxxxx1xx0111100x
14207                                                             fnmul.  */
14208                                                          return 838;
14209                                                        }
14210                                                      else
14211                                                        {
14212                                                          /* 33222222222211111111110000000000
14213                                                             10987654321098765432109876543210
14214                                                             xxxxxxxxxx010001xxxxx1xx0111101x
14215                                                             cmgt.  */
14216                                                          return 476;
14217                                                        }
14218                                                    }
14219                                                  else
14220                                                    {
14221                                                      /* 33222222222211111111110000000000
14222                                                         10987654321098765432109876543210
14223                                                         xxxxxxxxxx010001xxxxx1xx011111xx
14224                                                         cmge.  */
14225                                                      return 505;
14226                                                    }
14227                                                }
14228                                            }
14229                                        }
14230                                      else
14231                                        {
14232                                          if (((word >> 15) & 0x1) == 0)
14233                                            {
14234                                              if (((word >> 28) & 0x1) == 0)
14235                                                {
14236                                                  if (((word >> 16) & 0x1) == 0)
14237                                                    {
14238                                                      if (((word >> 19) & 0x1) == 0)
14239                                                        {
14240                                                          if (((word >> 29) & 0x1) == 0)
14241                                                            {
14242                                                              /* 33222222222211111111110000000000
14243                                                                 10987654321098765432109876543210
14244                                                                 xxxxxxxxxx0100100xx0x1xx011100xx
14245                                                                 cls.  */
14246                                                              return 160;
14247                                                            }
14248                                                          else
14249                                                            {
14250                                                              /* 33222222222211111111110000000000
14251                                                                 10987654321098765432109876543210
14252                                                                 xxxxxxxxxx0100100xx0x1xx011101xx
14253                                                                 clz.  */
14254                                                              return 210;
14255                                                            }
14256                                                        }
14257                                                      else
14258                                                        {
14259                                                          /* 33222222222211111111110000000000
14260                                                             10987654321098765432109876543210
14261                                                             xxxxxxxxxx0100100xx1x1xx01110xxx
14262                                                             aese.  */
14263                                                          return 665;
14264                                                        }
14265                                                    }
14266                                                  else
14267                                                    {
14268                                                      if (((word >> 29) & 0x1) == 0)
14269                                                        {
14270                                                          if (((word >> 30) & 0x1) == 0)
14271                                                            {
14272                                                              /* 33222222222211111111110000000000
14273                                                                 10987654321098765432109876543210
14274                                                                 xxxxxxxxxx0100101xxxx1xx0111000x
14275                                                                 sqxtn.  */
14276                                                              return 170;
14277                                                            }
14278                                                          else
14279                                                            {
14280                                                              /* 33222222222211111111110000000000
14281                                                                 10987654321098765432109876543210
14282                                                                 xxxxxxxxxx0100101xxxx1xx0111001x
14283                                                                 sqxtn2.  */
14284                                                              return 171;
14285                                                            }
14286                                                        }
14287                                                      else
14288                                                        {
14289                                                          if (((word >> 30) & 0x1) == 0)
14290                                                            {
14291                                                              /* 33222222222211111111110000000000
14292                                                                 10987654321098765432109876543210
14293                                                                 xxxxxxxxxx0100101xxxx1xx0111010x
14294                                                                 uqxtn.  */
14295                                                              return 220;
14296                                                            }
14297                                                          else
14298                                                            {
14299                                                              /* 33222222222211111111110000000000
14300                                                                 10987654321098765432109876543210
14301                                                                 xxxxxxxxxx0100101xxxx1xx0111011x
14302                                                                 uqxtn2.  */
14303                                                              return 221;
14304                                                            }
14305                                                        }
14306                                                    }
14307                                                }
14308                                              else
14309                                                {
14310                                                  if (((word >> 29) & 0x1) == 0)
14311                                                    {
14312                                                      if (((word >> 30) & 0x1) == 0)
14313                                                        {
14314                                                          /* 33222222222211111111110000000000
14315                                                             10987654321098765432109876543210
14316                                                             xxxxxxxxxx010010xxxxx1xx0111100x
14317                                                             fmax.  */
14318                                                          return 830;
14319                                                        }
14320                                                      else
14321                                                        {
14322                                                          /* 33222222222211111111110000000000
14323                                                             10987654321098765432109876543210
14324                                                             xxxxxxxxxx010010xxxxx1xx0111101x
14325                                                             sqxtn.  */
14326                                                          return 480;
14327                                                        }
14328                                                    }
14329                                                  else
14330                                                    {
14331                                                      /* 33222222222211111111110000000000
14332                                                         10987654321098765432109876543210
14333                                                         xxxxxxxxxx010010xxxxx1xx011111xx
14334                                                         uqxtn.  */
14335                                                      return 509;
14336                                                    }
14337                                                }
14338                                            }
14339                                          else
14340                                            {
14341                                              if (((word >> 16) & 0x1) == 0)
14342                                                {
14343                                                  if (((word >> 19) & 0x1) == 0)
14344                                                    {
14345                                                      if (((word >> 20) & 0x1) == 0)
14346                                                        {
14347                                                          if (((word >> 28) & 0x1) == 0)
14348                                                            {
14349                                                              if (((word >> 29) & 0x1) == 0)
14350                                                                {
14351                                                                  /* 33222222222211111111110000000000
14352                                                                     10987654321098765432109876543210
14353                                                                     xxxxxxxxxx0100110xx001xx011100xx
14354                                                                     fcmgt.  */
14355                                                                  return 188;
14356                                                                }
14357                                                              else
14358                                                                {
14359                                                                  /* 33222222222211111111110000000000
14360                                                                     10987654321098765432109876543210
14361                                                                     xxxxxxxxxx0100110xx001xx011101xx
14362                                                                     fcmge.  */
14363                                                                  return 239;
14364                                                                }
14365                                                            }
14366                                                          else
14367                                                            {
14368                                                              if (((word >> 29) & 0x1) == 0)
14369                                                                {
14370                                                                  /* 33222222222211111111110000000000
14371                                                                     10987654321098765432109876543210
14372                                                                     xxxxxxxxxx0100110xx001xx011110xx
14373                                                                     fcmgt.  */
14374                                                                  return 489;
14375                                                                }
14376                                                              else
14377                                                                {
14378                                                                  /* 33222222222211111111110000000000
14379                                                                     10987654321098765432109876543210
14380                                                                     xxxxxxxxxx0100110xx001xx011111xx
14381                                                                     fcmge.  */
14382                                                                  return 519;
14383                                                                }
14384                                                            }
14385                                                        }
14386                                                      else
14387                                                        {
14388                                                          if (((word >> 23) & 0x1) == 0)
14389                                                            {
14390                                                              if (((word >> 28) & 0x1) == 0)
14391                                                                {
14392                                                                  if (((word >> 29) & 0x1) == 0)
14393                                                                    {
14394                                                                      /* 33222222222211111111110000000000
14395                                                                         10987654321098765432109876543210
14396                                                                         xxxxxxxxxx0100110xx011x0011100xx
14397                                                                         fmaxnmv.  */
14398                                                                      return 35;
14399                                                                    }
14400                                                                  else
14401                                                                    {
14402                                                                      /* 33222222222211111111110000000000
14403                                                                         10987654321098765432109876543210
14404                                                                         xxxxxxxxxx0100110xx011x0011101xx
14405                                                                         fmaxnmv.  */
14406                                                                      return 34;
14407                                                                    }
14408                                                                }
14409                                                              else
14410                                                                {
14411                                                                  if (((word >> 29) & 0x1) == 0)
14412                                                                    {
14413                                                                      /* 33222222222211111111110000000000
14414                                                                         10987654321098765432109876543210
14415                                                                         xxxxxxxxxx0100110xx011x0011110xx
14416                                                                         fmaxnmp.  */
14417                                                                      return 533;
14418                                                                    }
14419                                                                  else
14420                                                                    {
14421                                                                      /* 33222222222211111111110000000000
14422                                                                         10987654321098765432109876543210
14423                                                                         xxxxxxxxxx0100110xx011x0011111xx
14424                                                                         fmaxnmp.  */
14425                                                                      return 532;
14426                                                                    }
14427                                                                }
14428                                                            }
14429                                                          else
14430                                                            {
14431                                                              if (((word >> 28) & 0x1) == 0)
14432                                                                {
14433                                                                  if (((word >> 29) & 0x1) == 0)
14434                                                                    {
14435                                                                      /* 33222222222211111111110000000000
14436                                                                         10987654321098765432109876543210
14437                                                                         xxxxxxxxxx0100110xx011x1011100xx
14438                                                                         fminnmv.  */
14439                                                                      return 39;
14440                                                                    }
14441                                                                  else
14442                                                                    {
14443                                                                      /* 33222222222211111111110000000000
14444                                                                         10987654321098765432109876543210
14445                                                                         xxxxxxxxxx0100110xx011x1011101xx
14446                                                                         fminnmv.  */
14447                                                                      return 38;
14448                                                                    }
14449                                                                }
14450                                                              else
14451                                                                {
14452                                                                  if (((word >> 29) & 0x1) == 0)
14453                                                                    {
14454                                                                      /* 33222222222211111111110000000000
14455                                                                         10987654321098765432109876543210
14456                                                                         xxxxxxxxxx0100110xx011x1011110xx
14457                                                                         fminnmp.  */
14458                                                                      return 539;
14459                                                                    }
14460                                                                  else
14461                                                                    {
14462                                                                      /* 33222222222211111111110000000000
14463                                                                         10987654321098765432109876543210
14464                                                                         xxxxxxxxxx0100110xx011x1011111xx
14465                                                                         fminnmp.  */
14466                                                                      return 538;
14467                                                                    }
14468                                                                }
14469                                                            }
14470                                                        }
14471                                                    }
14472                                                  else
14473                                                    {
14474                                                      if (((word >> 28) & 0x1) == 0)
14475                                                        {
14476                                                          if (((word >> 29) & 0x1) == 0)
14477                                                            {
14478                                                              /* 33222222222211111111110000000000
14479                                                                 10987654321098765432109876543210
14480                                                                 xxxxxxxxxx0100110xx1x1xx011100xx
14481                                                                 fcmgt.  */
14482                                                              return 189;
14483                                                            }
14484                                                          else
14485                                                            {
14486                                                              /* 33222222222211111111110000000000
14487                                                                 10987654321098765432109876543210
14488                                                                 xxxxxxxxxx0100110xx1x1xx011101xx
14489                                                                 fcmge.  */
14490                                                              return 240;
14491                                                            }
14492                                                        }
14493                                                      else
14494                                                        {
14495                                                          if (((word >> 29) & 0x1) == 0)
14496                                                            {
14497                                                              /* 33222222222211111111110000000000
14498                                                                 10987654321098765432109876543210
14499                                                                 xxxxxxxxxx0100110xx1x1xx011110xx
14500                                                                 fcmgt.  */
14501                                                              return 490;
14502                                                            }
14503                                                          else
14504                                                            {
14505                                                              /* 33222222222211111111110000000000
14506                                                                 10987654321098765432109876543210
14507                                                                 xxxxxxxxxx0100110xx1x1xx011111xx
14508                                                                 fcmge.  */
14509                                                              return 520;
14510                                                            }
14511                                                        }
14512                                                    }
14513                                                }
14514                                              else
14515                                                {
14516                                                  if (((word >> 19) & 0x1) == 0)
14517                                                    {
14518                                                      if (((word >> 23) & 0x1) == 0)
14519                                                        {
14520                                                          if (((word >> 28) & 0x1) == 0)
14521                                                            {
14522                                                              if (((word >> 29) & 0x1) == 0)
14523                                                                {
14524                                                                  /* 33222222222211111111110000000000
14525                                                                     10987654321098765432109876543210
14526                                                                     xxxxxxxxxx0100111xx0x1x0011100xx
14527                                                                     fcvtas.  */
14528                                                                  return 184;
14529                                                                }
14530                                                              else
14531                                                                {
14532                                                                  /* 33222222222211111111110000000000
14533                                                                     10987654321098765432109876543210
14534                                                                     xxxxxxxxxx0100111xx0x1x0011101xx
14535                                                                     fcvtau.  */
14536                                                                  return 232;
14537                                                                }
14538                                                            }
14539                                                          else
14540                                                            {
14541                                                              if (((word >> 29) & 0x1) == 0)
14542                                                                {
14543                                                                  /* 33222222222211111111110000000000
14544                                                                     10987654321098765432109876543210
14545                                                                     xxxxxxxxxx0100111xx0x1x0011110xx
14546                                                                     fcvtas.  */
14547                                                                  return 485;
14548                                                                }
14549                                                              else
14550                                                                {
14551                                                                  /* 33222222222211111111110000000000
14552                                                                     10987654321098765432109876543210
14553                                                                     xxxxxxxxxx0100111xx0x1x0011111xx
14554                                                                     fcvtau.  */
14555                                                                  return 515;
14556                                                                }
14557                                                            }
14558                                                        }
14559                                                      else
14560                                                        {
14561                                                          if (((word >> 29) & 0x1) == 0)
14562                                                            {
14563                                                              /* 33222222222211111111110000000000
14564                                                                 10987654321098765432109876543210
14565                                                                 xxxxxxxxxx0100111xx0x1x10111x0xx
14566                                                                 urecpe.  */
14567                                                              return 204;
14568                                                            }
14569                                                          else
14570                                                            {
14571                                                              /* 33222222222211111111110000000000
14572                                                                 10987654321098765432109876543210
14573                                                                 xxxxxxxxxx0100111xx0x1x10111x1xx
14574                                                                 ursqrte.  */
14575                                                              return 251;
14576                                                            }
14577                                                        }
14578                                                    }
14579                                                  else
14580                                                    {
14581                                                      if (((word >> 28) & 0x1) == 0)
14582                                                        {
14583                                                          if (((word >> 29) & 0x1) == 0)
14584                                                            {
14585                                                              /* 33222222222211111111110000000000
14586                                                                 10987654321098765432109876543210
14587                                                                 xxxxxxxxxx0100111xx1x1xx011100xx
14588                                                                 fcvtas.  */
14589                                                              return 185;
14590                                                            }
14591                                                          else
14592                                                            {
14593                                                              /* 33222222222211111111110000000000
14594                                                                 10987654321098765432109876543210
14595                                                                 xxxxxxxxxx0100111xx1x1xx011101xx
14596                                                                 fcvtau.  */
14597                                                              return 233;
14598                                                            }
14599                                                        }
14600                                                      else
14601                                                        {
14602                                                          if (((word >> 29) & 0x1) == 0)
14603                                                            {
14604                                                              /* 33222222222211111111110000000000
14605                                                                 10987654321098765432109876543210
14606                                                                 xxxxxxxxxx0100111xx1x1xx011110xx
14607                                                                 fcvtas.  */
14608                                                              return 486;
14609                                                            }
14610                                                          else
14611                                                            {
14612                                                              /* 33222222222211111111110000000000
14613                                                                 10987654321098765432109876543210
14614                                                                 xxxxxxxxxx0100111xx1x1xx011111xx
14615                                                                 fcvtau.  */
14616                                                              return 516;
14617                                                            }
14618                                                        }
14619                                                    }
14620                                                }
14621                                            }
14622                                        }
14623                                    }
14624                                  else
14625                                    {
14626                                      if (((word >> 14) & 0x1) == 0)
14627                                        {
14628                                          if (((word >> 15) & 0x1) == 0)
14629                                            {
14630                                              if (((word >> 28) & 0x1) == 0)
14631                                                {
14632                                                  if (((word >> 16) & 0x1) == 0)
14633                                                    {
14634                                                      if (((word >> 29) & 0x1) == 0)
14635                                                        {
14636                                                          /* 33222222222211111111110000000000
14637                                                             10987654321098765432109876543210
14638                                                             xxxxxxxxxx0101000xxxx1xx011100xx
14639                                                             saddlp.  */
14640                                                          return 158;
14641                                                        }
14642                                                      else
14643                                                        {
14644                                                          /* 33222222222211111111110000000000
14645                                                             10987654321098765432109876543210
14646                                                             xxxxxxxxxx0101000xxxx1xx011101xx
14647                                                             uaddlp.  */
14648                                                          return 208;
14649                                                        }
14650                                                    }
14651                                                  else
14652                                                    {
14653                                                      if (((word >> 29) & 0x1) == 0)
14654                                                        {
14655                                                          if (((word >> 30) & 0x1) == 0)
14656                                                            {
14657                                                              /* 33222222222211111111110000000000
14658                                                                 10987654321098765432109876543210
14659                                                                 xxxxxxxxxx0101001xxxx1xx0111000x
14660                                                                 xtn.  */
14661                                                              return 168;
14662                                                            }
14663                                                          else
14664                                                            {
14665                                                              /* 33222222222211111111110000000000
14666                                                                 10987654321098765432109876543210
14667                                                                 xxxxxxxxxx0101001xxxx1xx0111001x
14668                                                                 xtn2.  */
14669                                                              return 169;
14670                                                            }
14671                                                        }
14672                                                      else
14673                                                        {
14674                                                          if (((word >> 30) & 0x1) == 0)
14675                                                            {
14676                                                              /* 33222222222211111111110000000000
14677                                                                 10987654321098765432109876543210
14678                                                                 xxxxxxxxxx0101001xxxx1xx0111010x
14679                                                                 sqxtun.  */
14680                                                              return 216;
14681                                                            }
14682                                                          else
14683                                                            {
14684                                                              /* 33222222222211111111110000000000
14685                                                                 10987654321098765432109876543210
14686                                                                 xxxxxxxxxx0101001xxxx1xx0111011x
14687                                                                 sqxtun2.  */
14688                                                              return 217;
14689                                                            }
14690                                                        }
14691                                                    }
14692                                                }
14693                                              else
14694                                                {
14695                                                  if (((word >> 29) & 0x1) == 0)
14696                                                    {
14697                                                      if (((word >> 30) & 0x1) == 0)
14698                                                        {
14699                                                          /* 33222222222211111111110000000000
14700                                                             10987654321098765432109876543210
14701                                                             xxxxxxxxxx010100xxxxx1xx0111100x
14702                                                             fadd.  */
14703                                                          return 826;
14704                                                        }
14705                                                      else
14706                                                        {
14707                                                          /* 33222222222211111111110000000000
14708                                                             10987654321098765432109876543210
14709                                                             xxxxxxxxxx010100xxxxx1xx0111101x
14710                                                             sha256su0.  */
14711                                                          return 671;
14712                                                        }
14713                                                    }
14714                                                  else
14715                                                    {
14716                                                      /* 33222222222211111111110000000000
14717                                                         10987654321098765432109876543210
14718                                                         xxxxxxxxxx010100xxxxx1xx011111xx
14719                                                         sqxtun.  */
14720                                                      return 508;
14721                                                    }
14722                                                }
14723                                            }
14724                                          else
14725                                            {
14726                                              if (((word >> 16) & 0x1) == 0)
14727                                                {
14728                                                  if (((word >> 20) & 0x1) == 0)
14729                                                    {
14730                                                      if (((word >> 28) & 0x1) == 0)
14731                                                        {
14732                                                          /* 33222222222211111111110000000000
14733                                                             10987654321098765432109876543210
14734                                                             xxxxxxxxxx0101010xxx01xx01110xxx
14735                                                             cmlt.  */
14736                                                          return 166;
14737                                                        }
14738                                                      else
14739                                                        {
14740                                                          /* 33222222222211111111110000000000
14741                                                             10987654321098765432109876543210
14742                                                             xxxxxxxxxx0101010xxx01xx01111xxx
14743                                                             cmlt.  */
14744                                                          return 478;
14745                                                        }
14746                                                    }
14747                                                  else
14748                                                    {
14749                                                      if (((word >> 29) & 0x1) == 0)
14750                                                        {
14751                                                          /* 33222222222211111111110000000000
14752                                                             10987654321098765432109876543210
14753                                                             xxxxxxxxxx0101010xxx11xx0111x0xx
14754                                                             smaxv.  */
14755                                                          return 28;
14756                                                        }
14757                                                      else
14758                                                        {
14759                                                          /* 33222222222211111111110000000000
14760                                                             10987654321098765432109876543210
14761                                                             xxxxxxxxxx0101010xxx11xx0111x1xx
14762                                                             umaxv.  */
14763                                                          return 32;
14764                                                        }
14765                                                    }
14766                                                }
14767                                              else
14768                                                {
14769                                                  if (((word >> 19) & 0x1) == 0)
14770                                                    {
14771                                                      if (((word >> 20) & 0x1) == 0)
14772                                                        {
14773                                                          if (((word >> 23) & 0x1) == 0)
14774                                                            {
14775                                                              if (((word >> 28) & 0x1) == 0)
14776                                                                {
14777                                                                  if (((word >> 29) & 0x1) == 0)
14778                                                                    {
14779                                                                      /* 33222222222211111111110000000000
14780                                                                         10987654321098765432109876543210
14781                                                                         xxxxxxxxxx0101011xx001x0011100xx
14782                                                                         fcvtns.  */
14783                                                                      return 180;
14784                                                                    }
14785                                                                  else
14786                                                                    {
14787                                                                      /* 33222222222211111111110000000000
14788                                                                         10987654321098765432109876543210
14789                                                                         xxxxxxxxxx0101011xx001x0011101xx
14790                                                                         fcvtnu.  */
14791                                                                      return 228;
14792                                                                    }
14793                                                                }
14794                                                              else
14795                                                                {
14796                                                                  if (((word >> 29) & 0x1) == 0)
14797                                                                    {
14798                                                                      /* 33222222222211111111110000000000
14799                                                                         10987654321098765432109876543210
14800                                                                         xxxxxxxxxx0101011xx001x0011110xx
14801                                                                         fcvtns.  */
14802                                                                      return 481;
14803                                                                    }
14804                                                                  else
14805                                                                    {
14806                                                                      /* 33222222222211111111110000000000
14807                                                                         10987654321098765432109876543210
14808                                                                         xxxxxxxxxx0101011xx001x0011111xx
14809                                                                         fcvtnu.  */
14810                                                                      return 511;
14811                                                                    }
14812                                                                }
14813                                                            }
14814                                                          else
14815                                                            {
14816                                                              if (((word >> 28) & 0x1) == 0)
14817                                                                {
14818                                                                  if (((word >> 29) & 0x1) == 0)
14819                                                                    {
14820                                                                      /* 33222222222211111111110000000000
14821                                                                         10987654321098765432109876543210
14822                                                                         xxxxxxxxxx0101011xx001x1011100xx
14823                                                                         fcvtps.  */
14824                                                                      return 200;
14825                                                                    }
14826                                                                  else
14827                                                                    {
14828                                                                      /* 33222222222211111111110000000000
14829                                                                         10987654321098765432109876543210
14830                                                                         xxxxxxxxxx0101011xx001x1011101xx
14831                                                                         fcvtpu.  */
14832                                                                      return 247;
14833                                                                    }
14834                                                                }
14835                                                              else
14836                                                                {
14837                                                                  if (((word >> 29) & 0x1) == 0)
14838                                                                    {
14839                                                                      /* 33222222222211111111110000000000
14840                                                                         10987654321098765432109876543210
14841                                                                         xxxxxxxxxx0101011xx001x1011110xx
14842                                                                         fcvtps.  */
14843                                                                      return 495;
14844                                                                    }
14845                                                                  else
14846                                                                    {
14847                                                                      /* 33222222222211111111110000000000
14848                                                                         10987654321098765432109876543210
14849                                                                         xxxxxxxxxx0101011xx001x1011111xx
14850                                                                         fcvtpu.  */
14851                                                                      return 523;
14852                                                                    }
14853                                                                }
14854                                                            }
14855                                                        }
14856                                                      else
14857                                                        {
14858                                                          if (((word >> 29) & 0x1) == 0)
14859                                                            {
14860                                                              /* 33222222222211111111110000000000
14861                                                                 10987654321098765432109876543210
14862                                                                 xxxxxxxxxx0101011xx011xx0111x0xx
14863                                                                 sminv.  */
14864                                                              return 29;
14865                                                            }
14866                                                          else
14867                                                            {
14868                                                              /* 33222222222211111111110000000000
14869                                                                 10987654321098765432109876543210
14870                                                                 xxxxxxxxxx0101011xx011xx0111x1xx
14871                                                                 uminv.  */
14872                                                              return 33;
14873                                                            }
14874                                                        }
14875                                                    }
14876                                                  else
14877                                                    {
14878                                                      if (((word >> 23) & 0x1) == 0)
14879                                                        {
14880                                                          if (((word >> 28) & 0x1) == 0)
14881                                                            {
14882                                                              if (((word >> 29) & 0x1) == 0)
14883                                                                {
14884                                                                  /* 33222222222211111111110000000000
14885                                                                     10987654321098765432109876543210
14886                                                                     xxxxxxxxxx0101011xx1x1x0011100xx
14887                                                                     fcvtns.  */
14888                                                                  return 181;
14889                                                                }
14890                                                              else
14891                                                                {
14892                                                                  /* 33222222222211111111110000000000
14893                                                                     10987654321098765432109876543210
14894                                                                     xxxxxxxxxx0101011xx1x1x0011101xx
14895                                                                     fcvtnu.  */
14896                                                                  return 229;
14897                                                                }
14898                                                            }
14899                                                          else
14900                                                            {
14901                                                              if (((word >> 29) & 0x1) == 0)
14902                                                                {
14903                                                                  /* 33222222222211111111110000000000
14904                                                                     10987654321098765432109876543210
14905                                                                     xxxxxxxxxx0101011xx1x1x0011110xx
14906                                                                     fcvtns.  */
14907                                                                  return 482;
14908                                                                }
14909                                                              else
14910                                                                {
14911                                                                  /* 33222222222211111111110000000000
14912                                                                     10987654321098765432109876543210
14913                                                                     xxxxxxxxxx0101011xx1x1x0011111xx
14914                                                                     fcvtnu.  */
14915                                                                  return 512;
14916                                                                }
14917                                                            }
14918                                                        }
14919                                                      else
14920                                                        {
14921                                                          if (((word >> 28) & 0x1) == 0)
14922                                                            {
14923                                                              if (((word >> 29) & 0x1) == 0)
14924                                                                {
14925                                                                  /* 33222222222211111111110000000000
14926                                                                     10987654321098765432109876543210
14927                                                                     xxxxxxxxxx0101011xx1x1x1011100xx
14928                                                                     fcvtps.  */
14929                                                                  return 201;
14930                                                                }
14931                                                              else
14932                                                                {
14933                                                                  /* 33222222222211111111110000000000
14934                                                                     10987654321098765432109876543210
14935                                                                     xxxxxxxxxx0101011xx1x1x1011101xx
14936                                                                     fcvtpu.  */
14937                                                                  return 248;
14938                                                                }
14939                                                            }
14940                                                          else
14941                                                            {
14942                                                              if (((word >> 29) & 0x1) == 0)
14943                                                                {
14944                                                                  /* 33222222222211111111110000000000
14945                                                                     10987654321098765432109876543210
14946                                                                     xxxxxxxxxx0101011xx1x1x1011110xx
14947                                                                     fcvtps.  */
14948                                                                  return 496;
14949                                                                }
14950                                                              else
14951                                                                {
14952                                                                  /* 33222222222211111111110000000000
14953                                                                     10987654321098765432109876543210
14954                                                                     xxxxxxxxxx0101011xx1x1x1011111xx
14955                                                                     fcvtpu.  */
14956                                                                  return 524;
14957                                                                }
14958                                                            }
14959                                                        }
14960                                                    }
14961                                                }
14962                                            }
14963                                        }
14964                                      else
14965                                        {
14966                                          if (((word >> 15) & 0x1) == 0)
14967                                            {
14968                                              if (((word >> 28) & 0x1) == 0)
14969                                                {
14970                                                  if (((word >> 16) & 0x1) == 0)
14971                                                    {
14972                                                      if (((word >> 19) & 0x1) == 0)
14973                                                        {
14974                                                          if (((word >> 29) & 0x1) == 0)
14975                                                            {
14976                                                              /* 33222222222211111111110000000000
14977                                                                 10987654321098765432109876543210
14978                                                                 xxxxxxxxxx0101100xx0x1xx011100xx
14979                                                                 sadalp.  */
14980                                                              return 162;
14981                                                            }
14982                                                          else
14983                                                            {
14984                                                              /* 33222222222211111111110000000000
14985                                                                 10987654321098765432109876543210
14986                                                                 xxxxxxxxxx0101100xx0x1xx011101xx
14987                                                                 uadalp.  */
14988                                                              return 211;
14989                                                            }
14990                                                        }
14991                                                      else
14992                                                        {
14993                                                          /* 33222222222211111111110000000000
14994                                                             10987654321098765432109876543210
14995                                                             xxxxxxxxxx0101100xx1x1xx01110xxx
14996                                                             aesmc.  */
14997                                                          return 667;
14998                                                        }
14999                                                    }
15000                                                  else
15001                                                    {
15002                                                      if (((word >> 29) & 0x1) == 0)
15003                                                        {
15004                                                          if (((word >> 30) & 0x1) == 0)
15005                                                            {
15006                                                              /* 33222222222211111111110000000000
15007                                                                 10987654321098765432109876543210
15008                                                                 xxxxxxxxxx0101101xxxx1xx0111000x
15009                                                                 fcvtn.  */
15010                                                              return 172;
15011                                                            }
15012                                                          else
15013                                                            {
15014                                                              /* 33222222222211111111110000000000
15015                                                                 10987654321098765432109876543210
15016                                                                 xxxxxxxxxx0101101xxxx1xx0111001x
15017                                                                 fcvtn2.  */
15018                                                              return 173;
15019                                                            }
15020                                                        }
15021                                                      else
15022                                                        {
15023                                                          if (((word >> 30) & 0x1) == 0)
15024                                                            {
15025                                                              /* 33222222222211111111110000000000
15026                                                                 10987654321098765432109876543210
15027                                                                 xxxxxxxxxx0101101xxxx1xx0111010x
15028                                                                 fcvtxn.  */
15029                                                              return 222;
15030                                                            }
15031                                                          else
15032                                                            {
15033                                                              /* 33222222222211111111110000000000
15034                                                                 10987654321098765432109876543210
15035                                                                 xxxxxxxxxx0101101xxxx1xx0111011x
15036                                                                 fcvtxn2.  */
15037                                                              return 223;
15038                                                            }
15039                                                        }
15040                                                    }
15041                                                }
15042                                              else
15043                                                {
15044                                                  if (((word >> 29) & 0x1) == 0)
15045                                                    {
15046                                                      /* 33222222222211111111110000000000
15047                                                         10987654321098765432109876543210
15048                                                         xxxxxxxxxx010110xxxxx1xx011110xx
15049                                                         fmaxnm.  */
15050                                                      return 834;
15051                                                    }
15052                                                  else
15053                                                    {
15054                                                      /* 33222222222211111111110000000000
15055                                                         10987654321098765432109876543210
15056                                                         xxxxxxxxxx010110xxxxx1xx011111xx
15057                                                         fcvtxn.  */
15058                                                      return 510;
15059                                                    }
15060                                                }
15061                                            }
15062                                          else
15063                                            {
15064                                              if (((word >> 19) & 0x1) == 0)
15065                                                {
15066                                                  if (((word >> 28) & 0x1) == 0)
15067                                                    {
15068                                                      /* 33222222222211111111110000000000
15069                                                         10987654321098765432109876543210
15070                                                         xxxxxxxxxx010111xxx0x1xx01110xxx
15071                                                         fcmlt.  */
15072                                                      return 192;
15073                                                    }
15074                                                  else
15075                                                    {
15076                                                      /* 33222222222211111111110000000000
15077                                                         10987654321098765432109876543210
15078                                                         xxxxxxxxxx010111xxx0x1xx01111xxx
15079                                                         fcmlt.  */
15080                                                      return 493;
15081                                                    }
15082                                                }
15083                                              else
15084                                                {
15085                                                  if (((word >> 28) & 0x1) == 0)
15086                                                    {
15087                                                      /* 33222222222211111111110000000000
15088                                                         10987654321098765432109876543210
15089                                                         xxxxxxxxxx010111xxx1x1xx01110xxx
15090                                                         fcmlt.  */
15091                                                      return 193;
15092                                                    }
15093                                                  else
15094                                                    {
15095                                                      /* 33222222222211111111110000000000
15096                                                         10987654321098765432109876543210
15097                                                         xxxxxxxxxx010111xxx1x1xx01111xxx
15098                                                         fcmlt.  */
15099                                                      return 494;
15100                                                    }
15101                                                }
15102                                            }
15103                                        }
15104                                    }
15105                                }
15106                              else
15107                                {
15108                                  if (((word >> 13) & 0x1) == 0)
15109                                    {
15110                                      if (((word >> 14) & 0x1) == 0)
15111                                        {
15112                                          if (((word >> 15) & 0x1) == 0)
15113                                            {
15114                                              if (((word >> 28) & 0x1) == 0)
15115                                                {
15116                                                  /* 33222222222211111111110000000000
15117                                                     10987654321098765432109876543210
15118                                                     xxxxxxxxxx011000xxxxx1xx01110xxx
15119                                                     rev16.  */
15120                                                  return 157;
15121                                                }
15122                                              else
15123                                                {
15124                                                  if (((word >> 30) & 0x1) == 0)
15125                                                    {
15126                                                      /* 33222222222211111111110000000000
15127                                                         10987654321098765432109876543210
15128                                                         xxxxxxxxxx011000xxxxx1xx01111x0x
15129                                                         fdiv.  */
15130                                                      return 824;
15131                                                    }
15132                                                  else
15133                                                    {
15134                                                      /* 33222222222211111111110000000000
15135                                                         10987654321098765432109876543210
15136                                                         xxxxxxxxxx011000xxxxx1xx01111x1x
15137                                                         sha1su1.  */
15138                                                      return 670;
15139                                                    }
15140                                                }
15141                                            }
15142                                          else
15143                                            {
15144                                              if (((word >> 16) & 0x1) == 0)
15145                                                {
15146                                                  if (((word >> 28) & 0x1) == 0)
15147                                                    {
15148                                                      if (((word >> 29) & 0x1) == 0)
15149                                                        {
15150                                                          /* 33222222222211111111110000000000
15151                                                             10987654321098765432109876543210
15152                                                             xxxxxxxxxx0110010xxxx1xx011100xx
15153                                                             cmeq.  */
15154                                                          return 165;
15155                                                        }
15156                                                      else
15157                                                        {
15158                                                          /* 33222222222211111111110000000000
15159                                                             10987654321098765432109876543210
15160                                                             xxxxxxxxxx0110010xxxx1xx011101xx
15161                                                             cmle.  */
15162                                                          return 214;
15163                                                        }
15164                                                    }
15165                                                  else
15166                                                    {
15167                                                      if (((word >> 29) & 0x1) == 0)
15168                                                        {
15169                                                          /* 33222222222211111111110000000000
15170                                                             10987654321098765432109876543210
15171                                                             xxxxxxxxxx0110010xxxx1xx011110xx
15172                                                             cmeq.  */
15173                                                          return 477;
15174                                                        }
15175                                                      else
15176                                                        {
15177                                                          /* 33222222222211111111110000000000
15178                                                             10987654321098765432109876543210
15179                                                             xxxxxxxxxx0110010xxxx1xx011111xx
15180                                                             cmle.  */
15181                                                          return 506;
15182                                                        }
15183                                                    }
15184                                                }
15185                                              else
15186                                                {
15187                                                  if (((word >> 19) & 0x1) == 0)
15188                                                    {
15189                                                      if (((word >> 23) & 0x1) == 0)
15190                                                        {
15191                                                          if (((word >> 29) & 0x1) == 0)
15192                                                            {
15193                                                              /* 33222222222211111111110000000000
15194                                                                 10987654321098765432109876543210
15195                                                                 xxxxxxxxxx0110011xx0x1x00111x0xx
15196                                                                 frintm.  */
15197                                                              return 178;
15198                                                            }
15199                                                          else
15200                                                            {
15201                                                              /* 33222222222211111111110000000000
15202                                                                 10987654321098765432109876543210
15203                                                                 xxxxxxxxxx0110011xx0x1x00111x1xx
15204                                                                 frintx.  */
15205                                                              return 226;
15206                                                            }
15207                                                        }
15208                                                      else
15209                                                        {
15210                                                          if (((word >> 29) & 0x1) == 0)
15211                                                            {
15212                                                              /* 33222222222211111111110000000000
15213                                                                 10987654321098765432109876543210
15214                                                                 xxxxxxxxxx0110011xx0x1x10111x0xx
15215                                                                 frintz.  */
15216                                                              return 198;
15217                                                            }
15218                                                          else
15219                                                            {
15220                                                              /* 33222222222211111111110000000000
15221                                                                 10987654321098765432109876543210
15222                                                                 xxxxxxxxxx0110011xx0x1x10111x1xx
15223                                                                 frinti.  */
15224                                                              return 245;
15225                                                            }
15226                                                        }
15227                                                    }
15228                                                  else
15229                                                    {
15230                                                      if (((word >> 23) & 0x1) == 0)
15231                                                        {
15232                                                          if (((word >> 29) & 0x1) == 0)
15233                                                            {
15234                                                              /* 33222222222211111111110000000000
15235                                                                 10987654321098765432109876543210
15236                                                                 xxxxxxxxxx0110011xx1x1x00111x0xx
15237                                                                 frintm.  */
15238                                                              return 179;
15239                                                            }
15240                                                          else
15241                                                            {
15242                                                              /* 33222222222211111111110000000000
15243                                                                 10987654321098765432109876543210
15244                                                                 xxxxxxxxxx0110011xx1x1x00111x1xx
15245                                                                 frintx.  */
15246                                                              return 227;
15247                                                            }
15248                                                        }
15249                                                      else
15250                                                        {
15251                                                          if (((word >> 29) & 0x1) == 0)
15252                                                            {
15253                                                              /* 33222222222211111111110000000000
15254                                                                 10987654321098765432109876543210
15255                                                                 xxxxxxxxxx0110011xx1x1x10111x0xx
15256                                                                 frintz.  */
15257                                                              return 199;
15258                                                            }
15259                                                          else
15260                                                            {
15261                                                              /* 33222222222211111111110000000000
15262                                                                 10987654321098765432109876543210
15263                                                                 xxxxxxxxxx0110011xx1x1x10111x1xx
15264                                                                 frinti.  */
15265                                                              return 246;
15266                                                            }
15267                                                        }
15268                                                    }
15269                                                }
15270                                            }
15271                                        }
15272                                      else
15273                                        {
15274                                          if (((word >> 15) & 0x1) == 0)
15275                                            {
15276                                              if (((word >> 28) & 0x1) == 0)
15277                                                {
15278                                                  if (((word >> 19) & 0x1) == 0)
15279                                                    {
15280                                                      if (((word >> 29) & 0x1) == 0)
15281                                                        {
15282                                                          /* 33222222222211111111110000000000
15283                                                             10987654321098765432109876543210
15284                                                             xxxxxxxxxx011010xxx0x1xx011100xx
15285                                                             cnt.  */
15286                                                          return 161;
15287                                                        }
15288                                                      else
15289                                                        {
15290                                                          if (((word >> 22) & 0x1) == 0)
15291                                                            {
15292                                                              /* 33222222222211111111110000000000
15293                                                                 10987654321098765432109876543210
15294                                                                 xxxxxxxxxx011010xxx0x10x011101xx
15295                                                                 not.  */
15296                                                              return 236;
15297                                                            }
15298                                                          else
15299                                                            {
15300                                                              /* 33222222222211111111110000000000
15301                                                                 10987654321098765432109876543210
15302                                                                 xxxxxxxxxx011010xxx0x11x011101xx
15303                                                                 rbit.  */
15304                                                              return 238;
15305                                                            }
15306                                                        }
15307                                                    }
15308                                                  else
15309                                                    {
15310                                                      /* 33222222222211111111110000000000
15311                                                         10987654321098765432109876543210
15312                                                         xxxxxxxxxx011010xxx1x1xx01110xxx
15313                                                         aesd.  */
15314                                                      return 666;
15315                                                    }
15316                                                }
15317                                              else
15318                                                {
15319                                                  /* 33222222222211111111110000000000
15320                                                     10987654321098765432109876543210
15321                                                     xxxxxxxxxx011010xxxxx1xx01111xxx
15322                                                     fmin.  */
15323                                                  return 832;
15324                                                }
15325                                            }
15326                                          else
15327                                            {
15328                                              if (((word >> 16) & 0x1) == 0)
15329                                                {
15330                                                  if (((word >> 19) & 0x1) == 0)
15331                                                    {
15332                                                      if (((word >> 20) & 0x1) == 0)
15333                                                        {
15334                                                          if (((word >> 28) & 0x1) == 0)
15335                                                            {
15336                                                              if (((word >> 29) & 0x1) == 0)
15337                                                                {
15338                                                                  /* 33222222222211111111110000000000
15339                                                                     10987654321098765432109876543210
15340                                                                     xxxxxxxxxx0110110xx001xx011100xx
15341                                                                     fcmeq.  */
15342                                                                  return 190;
15343                                                                }
15344                                                              else
15345                                                                {
15346                                                                  /* 33222222222211111111110000000000
15347                                                                     10987654321098765432109876543210
15348                                                                     xxxxxxxxxx0110110xx001xx011101xx
15349                                                                     fcmle.  */
15350                                                                  return 241;
15351                                                                }
15352                                                            }
15353                                                          else
15354                                                            {
15355                                                              if (((word >> 29) & 0x1) == 0)
15356                                                                {
15357                                                                  /* 33222222222211111111110000000000
15358                                                                     10987654321098765432109876543210
15359                                                                     xxxxxxxxxx0110110xx001xx011110xx
15360                                                                     fcmeq.  */
15361                                                                  return 491;
15362                                                                }
15363                                                              else
15364                                                                {
15365                                                                  /* 33222222222211111111110000000000
15366                                                                     10987654321098765432109876543210
15367                                                                     xxxxxxxxxx0110110xx001xx011111xx
15368                                                                     fcmle.  */
15369                                                                  return 521;
15370                                                                }
15371                                                            }
15372                                                        }
15373                                                      else
15374                                                        {
15375                                                          if (((word >> 29) & 0x1) == 0)
15376                                                            {
15377                                                              /* 33222222222211111111110000000000
15378                                                                 10987654321098765432109876543210
15379                                                                 xxxxxxxxxx0110110xx011xx0111x0xx
15380                                                                 faddp.  */
15381                                                              return 535;
15382                                                            }
15383                                                          else
15384                                                            {
15385                                                              /* 33222222222211111111110000000000
15386                                                                 10987654321098765432109876543210
15387                                                                 xxxxxxxxxx0110110xx011xx0111x1xx
15388                                                                 faddp.  */
15389                                                              return 534;
15390                                                            }
15391                                                        }
15392                                                    }
15393                                                  else
15394                                                    {
15395                                                      if (((word >> 28) & 0x1) == 0)
15396                                                        {
15397                                                          if (((word >> 29) & 0x1) == 0)
15398                                                            {
15399                                                              /* 33222222222211111111110000000000
15400                                                                 10987654321098765432109876543210
15401                                                                 xxxxxxxxxx0110110xx1x1xx011100xx
15402                                                                 fcmeq.  */
15403                                                              return 191;
15404                                                            }
15405                                                          else
15406                                                            {
15407                                                              /* 33222222222211111111110000000000
15408                                                                 10987654321098765432109876543210
15409                                                                 xxxxxxxxxx0110110xx1x1xx011101xx
15410                                                                 fcmle.  */
15411                                                              return 242;
15412                                                            }
15413                                                        }
15414                                                      else
15415                                                        {
15416                                                          if (((word >> 29) & 0x1) == 0)
15417                                                            {
15418                                                              /* 33222222222211111111110000000000
15419                                                                 10987654321098765432109876543210
15420                                                                 xxxxxxxxxx0110110xx1x1xx011110xx
15421                                                                 fcmeq.  */
15422                                                              return 492;
15423                                                            }
15424                                                          else
15425                                                            {
15426                                                              /* 33222222222211111111110000000000
15427                                                                 10987654321098765432109876543210
15428                                                                 xxxxxxxxxx0110110xx1x1xx011111xx
15429                                                                 fcmle.  */
15430                                                              return 522;
15431                                                            }
15432                                                        }
15433                                                    }
15434                                                }
15435                                              else
15436                                                {
15437                                                  if (((word >> 19) & 0x1) == 0)
15438                                                    {
15439                                                      if (((word >> 23) & 0x1) == 0)
15440                                                        {
15441                                                          if (((word >> 28) & 0x1) == 0)
15442                                                            {
15443                                                              if (((word >> 29) & 0x1) == 0)
15444                                                                {
15445                                                                  /* 33222222222211111111110000000000
15446                                                                     10987654321098765432109876543210
15447                                                                     xxxxxxxxxx0110111xx0x1x0011100xx
15448                                                                     scvtf.  */
15449                                                                  return 186;
15450                                                                }
15451                                                              else
15452                                                                {
15453                                                                  /* 33222222222211111111110000000000
15454                                                                     10987654321098765432109876543210
15455                                                                     xxxxxxxxxx0110111xx0x1x0011101xx
15456                                                                     ucvtf.  */
15457                                                                  return 234;
15458                                                                }
15459                                                            }
15460                                                          else
15461                                                            {
15462                                                              if (((word >> 29) & 0x1) == 0)
15463                                                                {
15464                                                                  /* 33222222222211111111110000000000
15465                                                                     10987654321098765432109876543210
15466                                                                     xxxxxxxxxx0110111xx0x1x0011110xx
15467                                                                     scvtf.  */
15468                                                                  return 487;
15469                                                                }
15470                                                              else
15471                                                                {
15472                                                                  /* 33222222222211111111110000000000
15473                                                                     10987654321098765432109876543210
15474                                                                     xxxxxxxxxx0110111xx0x1x0011111xx
15475                                                                     ucvtf.  */
15476                                                                  return 517;
15477                                                                }
15478                                                            }
15479                                                        }
15480                                                      else
15481                                                        {
15482                                                          if (((word >> 28) & 0x1) == 0)
15483                                                            {
15484                                                              if (((word >> 29) & 0x1) == 0)
15485                                                                {
15486                                                                  /* 33222222222211111111110000000000
15487                                                                     10987654321098765432109876543210
15488                                                                     xxxxxxxxxx0110111xx0x1x1011100xx
15489                                                                     frecpe.  */
15490                                                                  return 205;
15491                                                                }
15492                                                              else
15493                                                                {
15494                                                                  /* 33222222222211111111110000000000
15495                                                                     10987654321098765432109876543210
15496                                                                     xxxxxxxxxx0110111xx0x1x1011101xx
15497                                                                     frsqrte.  */
15498                                                                  return 252;
15499                                                                }
15500                                                            }
15501                                                          else
15502                                                            {
15503                                                              if (((word >> 29) & 0x1) == 0)
15504                                                                {
15505                                                                  /* 33222222222211111111110000000000
15506                                                                     10987654321098765432109876543210
15507                                                                     xxxxxxxxxx0110111xx0x1x1011110xx
15508                                                                     frecpe.  */
15509                                                                  return 499;
15510                                                                }
15511                                                              else
15512                                                                {
15513                                                                  /* 33222222222211111111110000000000
15514                                                                     10987654321098765432109876543210
15515                                                                     xxxxxxxxxx0110111xx0x1x1011111xx
15516                                                                     frsqrte.  */
15517                                                                  return 527;
15518                                                                }
15519                                                            }
15520                                                        }
15521                                                    }
15522                                                  else
15523                                                    {
15524                                                      if (((word >> 23) & 0x1) == 0)
15525                                                        {
15526                                                          if (((word >> 28) & 0x1) == 0)
15527                                                            {
15528                                                              if (((word >> 29) & 0x1) == 0)
15529                                                                {
15530                                                                  /* 33222222222211111111110000000000
15531                                                                     10987654321098765432109876543210
15532                                                                     xxxxxxxxxx0110111xx1x1x0011100xx
15533                                                                     scvtf.  */
15534                                                                  return 187;
15535                                                                }
15536                                                              else
15537                                                                {
15538                                                                  /* 33222222222211111111110000000000
15539                                                                     10987654321098765432109876543210
15540                                                                     xxxxxxxxxx0110111xx1x1x0011101xx
15541                                                                     ucvtf.  */
15542                                                                  return 235;
15543                                                                }
15544                                                            }
15545                                                          else
15546                                                            {
15547                                                              if (((word >> 29) & 0x1) == 0)
15548                                                                {
15549                                                                  /* 33222222222211111111110000000000
15550                                                                     10987654321098765432109876543210
15551                                                                     xxxxxxxxxx0110111xx1x1x0011110xx
15552                                                                     scvtf.  */
15553                                                                  return 488;
15554                                                                }
15555                                                              else
15556                                                                {
15557                                                                  /* 33222222222211111111110000000000
15558                                                                     10987654321098765432109876543210
15559                                                                     xxxxxxxxxx0110111xx1x1x0011111xx
15560                                                                     ucvtf.  */
15561                                                                  return 518;
15562                                                                }
15563                                                            }
15564                                                        }
15565                                                      else
15566                                                        {
15567                                                          if (((word >> 28) & 0x1) == 0)
15568                                                            {
15569                                                              if (((word >> 29) & 0x1) == 0)
15570                                                                {
15571                                                                  /* 33222222222211111111110000000000
15572                                                                     10987654321098765432109876543210
15573                                                                     xxxxxxxxxx0110111xx1x1x1011100xx
15574                                                                     frecpe.  */
15575                                                                  return 206;
15576                                                                }
15577                                                              else
15578                                                                {
15579                                                                  /* 33222222222211111111110000000000
15580                                                                     10987654321098765432109876543210
15581                                                                     xxxxxxxxxx0110111xx1x1x1011101xx
15582                                                                     frsqrte.  */
15583                                                                  return 253;
15584                                                                }
15585                                                            }
15586                                                          else
15587                                                            {
15588                                                              if (((word >> 29) & 0x1) == 0)
15589                                                                {
15590                                                                  /* 33222222222211111111110000000000
15591                                                                     10987654321098765432109876543210
15592                                                                     xxxxxxxxxx0110111xx1x1x1011110xx
15593                                                                     frecpe.  */
15594                                                                  return 500;
15595                                                                }
15596                                                              else
15597                                                                {
15598                                                                  /* 33222222222211111111110000000000
15599                                                                     10987654321098765432109876543210
15600                                                                     xxxxxxxxxx0110111xx1x1x1011111xx
15601                                                                     frsqrte.  */
15602                                                                  return 528;
15603                                                                }
15604                                                            }
15605                                                        }
15606                                                    }
15607                                                }
15608                                            }
15609                                        }
15610                                    }
15611                                  else
15612                                    {
15613                                      if (((word >> 14) & 0x1) == 0)
15614                                        {
15615                                          if (((word >> 15) & 0x1) == 0)
15616                                            {
15617                                              if (((word >> 28) & 0x1) == 0)
15618                                                {
15619                                                  if (((word >> 16) & 0x1) == 0)
15620                                                    {
15621                                                      if (((word >> 20) & 0x1) == 0)
15622                                                        {
15623                                                          if (((word >> 29) & 0x1) == 0)
15624                                                            {
15625                                                              /* 33222222222211111111110000000000
15626                                                                 10987654321098765432109876543210
15627                                                                 xxxxxxxxxx0111000xxx01xx011100xx
15628                                                                 suqadd.  */
15629                                                              return 159;
15630                                                            }
15631                                                          else
15632                                                            {
15633                                                              /* 33222222222211111111110000000000
15634                                                                 10987654321098765432109876543210
15635                                                                 xxxxxxxxxx0111000xxx01xx011101xx
15636                                                                 usqadd.  */
15637                                                              return 209;
15638                                                            }
15639                                                        }
15640                                                      else
15641                                                        {
15642                                                          if (((word >> 29) & 0x1) == 0)
15643                                                            {
15644                                                              /* 33222222222211111111110000000000
15645                                                                 10987654321098765432109876543210
15646                                                                 xxxxxxxxxx0111000xxx11xx011100xx
15647                                                                 saddlv.  */
15648                                                              return 27;
15649                                                            }
15650                                                          else
15651                                                            {
15652                                                              /* 33222222222211111111110000000000
15653                                                                 10987654321098765432109876543210
15654                                                                 xxxxxxxxxx0111000xxx11xx011101xx
15655                                                                 uaddlv.  */
15656                                                              return 31;
15657                                                            }
15658                                                        }
15659                                                    }
15660                                                  else
15661                                                    {
15662                                                      if (((word >> 30) & 0x1) == 0)
15663                                                        {
15664                                                          /* 33222222222211111111110000000000
15665                                                             10987654321098765432109876543210
15666                                                             xxxxxxxxxx0111001xxxx1xx01110x0x
15667                                                             shll.  */
15668                                                          return 218;
15669                                                        }
15670                                                      else
15671                                                        {
15672                                                          /* 33222222222211111111110000000000
15673                                                             10987654321098765432109876543210
15674                                                             xxxxxxxxxx0111001xxxx1xx01110x1x
15675                                                             shll2.  */
15676                                                          return 219;
15677                                                        }
15678                                                    }
15679                                                }
15680                                              else
15681                                                {
15682                                                  if (((word >> 29) & 0x1) == 0)
15683                                                    {
15684                                                      if (((word >> 30) & 0x1) == 0)
15685                                                        {
15686                                                          /* 33222222222211111111110000000000
15687                                                             10987654321098765432109876543210
15688                                                             xxxxxxxxxx011100xxxxx1xx0111100x
15689                                                             fsub.  */
15690                                                          return 828;
15691                                                        }
15692                                                      else
15693                                                        {
15694                                                          /* 33222222222211111111110000000000
15695                                                             10987654321098765432109876543210
15696                                                             xxxxxxxxxx011100xxxxx1xx0111101x
15697                                                             suqadd.  */
15698                                                          return 474;
15699                                                        }
15700                                                    }
15701                                                  else
15702                                                    {
15703                                                      /* 33222222222211111111110000000000
15704                                                         10987654321098765432109876543210
15705                                                         xxxxxxxxxx011100xxxxx1xx011111xx
15706                                                         usqadd.  */
15707                                                      return 503;
15708                                                    }
15709                                                }
15710                                            }
15711                                          else
15712                                            {
15713                                              if (((word >> 16) & 0x1) == 0)
15714                                                {
15715                                                  if (((word >> 28) & 0x1) == 0)
15716                                                    {
15717                                                      if (((word >> 29) & 0x1) == 0)
15718                                                        {
15719                                                          /* 33222222222211111111110000000000
15720                                                             10987654321098765432109876543210
15721                                                             xxxxxxxxxx0111010xxxx1xx011100xx
15722                                                             abs.  */
15723                                                          return 167;
15724                                                        }
15725                                                      else
15726                                                        {
15727                                                          /* 33222222222211111111110000000000
15728                                                             10987654321098765432109876543210
15729                                                             xxxxxxxxxx0111010xxxx1xx011101xx
15730                                                             neg.  */
15731                                                          return 215;
15732                                                        }
15733                                                    }
15734                                                  else
15735                                                    {
15736                                                      if (((word >> 29) & 0x1) == 0)
15737                                                        {
15738                                                          /* 33222222222211111111110000000000
15739                                                             10987654321098765432109876543210
15740                                                             xxxxxxxxxx0111010xxxx1xx011110xx
15741                                                             abs.  */
15742                                                          return 479;
15743                                                        }
15744                                                      else
15745                                                        {
15746                                                          /* 33222222222211111111110000000000
15747                                                             10987654321098765432109876543210
15748                                                             xxxxxxxxxx0111010xxxx1xx011111xx
15749                                                             neg.  */
15750                                                          return 507;
15751                                                        }
15752                                                    }
15753                                                }
15754                                              else
15755                                                {
15756                                                  if (((word >> 19) & 0x1) == 0)
15757                                                    {
15758                                                      if (((word >> 20) & 0x1) == 0)
15759                                                        {
15760                                                          if (((word >> 23) & 0x1) == 0)
15761                                                            {
15762                                                              if (((word >> 28) & 0x1) == 0)
15763                                                                {
15764                                                                  if (((word >> 29) & 0x1) == 0)
15765                                                                    {
15766                                                                      /* 33222222222211111111110000000000
15767                                                                         10987654321098765432109876543210
15768                                                                         xxxxxxxxxx0111011xx001x0011100xx
15769                                                                         fcvtms.  */
15770                                                                      return 182;
15771                                                                    }
15772                                                                  else
15773                                                                    {
15774                                                                      /* 33222222222211111111110000000000
15775                                                                         10987654321098765432109876543210
15776                                                                         xxxxxxxxxx0111011xx001x0011101xx
15777                                                                         fcvtmu.  */
15778                                                                      return 230;
15779                                                                    }
15780                                                                }
15781                                                              else
15782                                                                {
15783                                                                  if (((word >> 29) & 0x1) == 0)
15784                                                                    {
15785                                                                      /* 33222222222211111111110000000000
15786                                                                         10987654321098765432109876543210
15787                                                                         xxxxxxxxxx0111011xx001x0011110xx
15788                                                                         fcvtms.  */
15789                                                                      return 483;
15790                                                                    }
15791                                                                  else
15792                                                                    {
15793                                                                      /* 33222222222211111111110000000000
15794                                                                         10987654321098765432109876543210
15795                                                                         xxxxxxxxxx0111011xx001x0011111xx
15796                                                                         fcvtmu.  */
15797                                                                      return 513;
15798                                                                    }
15799                                                                }
15800                                                            }
15801                                                          else
15802                                                            {
15803                                                              if (((word >> 28) & 0x1) == 0)
15804                                                                {
15805                                                                  if (((word >> 29) & 0x1) == 0)
15806                                                                    {
15807                                                                      /* 33222222222211111111110000000000
15808                                                                         10987654321098765432109876543210
15809                                                                         xxxxxxxxxx0111011xx001x1011100xx
15810                                                                         fcvtzs.  */
15811                                                                      return 202;
15812                                                                    }
15813                                                                  else
15814                                                                    {
15815                                                                      /* 33222222222211111111110000000000
15816                                                                         10987654321098765432109876543210
15817                                                                         xxxxxxxxxx0111011xx001x1011101xx
15818                                                                         fcvtzu.  */
15819                                                                      return 249;
15820                                                                    }
15821                                                                }
15822                                                              else
15823                                                                {
15824                                                                  if (((word >> 29) & 0x1) == 0)
15825                                                                    {
15826                                                                      /* 33222222222211111111110000000000
15827                                                                         10987654321098765432109876543210
15828                                                                         xxxxxxxxxx0111011xx001x1011110xx
15829                                                                         fcvtzs.  */
15830                                                                      return 497;
15831                                                                    }
15832                                                                  else
15833                                                                    {
15834                                                                      /* 33222222222211111111110000000000
15835                                                                         10987654321098765432109876543210
15836                                                                         xxxxxxxxxx0111011xx001x1011111xx
15837                                                                         fcvtzu.  */
15838                                                                      return 525;
15839                                                                    }
15840                                                                }
15841                                                            }
15842                                                        }
15843                                                      else
15844                                                        {
15845                                                          if (((word >> 28) & 0x1) == 0)
15846                                                            {
15847                                                              /* 33222222222211111111110000000000
15848                                                                 10987654321098765432109876543210
15849                                                                 xxxxxxxxxx0111011xx011xx01110xxx
15850                                                                 addv.  */
15851                                                              return 30;
15852                                                            }
15853                                                          else
15854                                                            {
15855                                                              /* 33222222222211111111110000000000
15856                                                                 10987654321098765432109876543210
15857                                                                 xxxxxxxxxx0111011xx011xx01111xxx
15858                                                                 addp.  */
15859                                                              return 531;
15860                                                            }
15861                                                        }
15862                                                    }
15863                                                  else
15864                                                    {
15865                                                      if (((word >> 23) & 0x1) == 0)
15866                                                        {
15867                                                          if (((word >> 28) & 0x1) == 0)
15868                                                            {
15869                                                              if (((word >> 29) & 0x1) == 0)
15870                                                                {
15871                                                                  /* 33222222222211111111110000000000
15872                                                                     10987654321098765432109876543210
15873                                                                     xxxxxxxxxx0111011xx1x1x0011100xx
15874                                                                     fcvtms.  */
15875                                                                  return 183;
15876                                                                }
15877                                                              else
15878                                                                {
15879                                                                  /* 33222222222211111111110000000000
15880                                                                     10987654321098765432109876543210
15881                                                                     xxxxxxxxxx0111011xx1x1x0011101xx
15882                                                                     fcvtmu.  */
15883                                                                  return 231;
15884                                                                }
15885                                                            }
15886                                                          else
15887                                                            {
15888                                                              if (((word >> 29) & 0x1) == 0)
15889                                                                {
15890                                                                  /* 33222222222211111111110000000000
15891                                                                     10987654321098765432109876543210
15892                                                                     xxxxxxxxxx0111011xx1x1x0011110xx
15893                                                                     fcvtms.  */
15894                                                                  return 484;
15895                                                                }
15896                                                              else
15897                                                                {
15898                                                                  /* 33222222222211111111110000000000
15899                                                                     10987654321098765432109876543210
15900                                                                     xxxxxxxxxx0111011xx1x1x0011111xx
15901                                                                     fcvtmu.  */
15902                                                                  return 514;
15903                                                                }
15904                                                            }
15905                                                        }
15906                                                      else
15907                                                        {
15908                                                          if (((word >> 28) & 0x1) == 0)
15909                                                            {
15910                                                              if (((word >> 29) & 0x1) == 0)
15911                                                                {
15912                                                                  /* 33222222222211111111110000000000
15913                                                                     10987654321098765432109876543210
15914                                                                     xxxxxxxxxx0111011xx1x1x1011100xx
15915                                                                     fcvtzs.  */
15916                                                                  return 203;
15917                                                                }
15918                                                              else
15919                                                                {
15920                                                                  /* 33222222222211111111110000000000
15921                                                                     10987654321098765432109876543210
15922                                                                     xxxxxxxxxx0111011xx1x1x1011101xx
15923                                                                     fcvtzu.  */
15924                                                                  return 250;
15925                                                                }
15926                                                            }
15927                                                          else
15928                                                            {
15929                                                              if (((word >> 29) & 0x1) == 0)
15930                                                                {
15931                                                                  /* 33222222222211111111110000000000
15932                                                                     10987654321098765432109876543210
15933                                                                     xxxxxxxxxx0111011xx1x1x1011110xx
15934                                                                     fcvtzs.  */
15935                                                                  return 498;
15936                                                                }
15937                                                              else
15938                                                                {
15939                                                                  /* 33222222222211111111110000000000
15940                                                                     10987654321098765432109876543210
15941                                                                     xxxxxxxxxx0111011xx1x1x1011111xx
15942                                                                     fcvtzu.  */
15943                                                                  return 526;
15944                                                                }
15945                                                            }
15946                                                        }
15947                                                    }
15948                                                }
15949                                            }
15950                                        }
15951                                      else
15952                                        {
15953                                          if (((word >> 15) & 0x1) == 0)
15954                                            {
15955                                              if (((word >> 28) & 0x1) == 0)
15956                                                {
15957                                                  if (((word >> 16) & 0x1) == 0)
15958                                                    {
15959                                                      if (((word >> 19) & 0x1) == 0)
15960                                                        {
15961                                                          if (((word >> 29) & 0x1) == 0)
15962                                                            {
15963                                                              /* 33222222222211111111110000000000
15964                                                                 10987654321098765432109876543210
15965                                                                 xxxxxxxxxx0111100xx0x1xx011100xx
15966                                                                 sqabs.  */
15967                                                              return 163;
15968                                                            }
15969                                                          else
15970                                                            {
15971                                                              /* 33222222222211111111110000000000
15972                                                                 10987654321098765432109876543210
15973                                                                 xxxxxxxxxx0111100xx0x1xx011101xx
15974                                                                 sqneg.  */
15975                                                              return 212;
15976                                                            }
15977                                                        }
15978                                                      else
15979                                                        {
15980                                                          /* 33222222222211111111110000000000
15981                                                             10987654321098765432109876543210
15982                                                             xxxxxxxxxx0111100xx1x1xx01110xxx
15983                                                             aesimc.  */
15984                                                          return 668;
15985                                                        }
15986                                                    }
15987                                                  else
15988                                                    {
15989                                                      if (((word >> 30) & 0x1) == 0)
15990                                                        {
15991                                                          /* 33222222222211111111110000000000
15992                                                             10987654321098765432109876543210
15993                                                             xxxxxxxxxx0111101xxxx1xx01110x0x
15994                                                             fcvtl.  */
15995                                                          return 174;
15996                                                        }
15997                                                      else
15998                                                        {
15999                                                          /* 33222222222211111111110000000000
16000                                                             10987654321098765432109876543210
16001                                                             xxxxxxxxxx0111101xxxx1xx01110x1x
16002                                                             fcvtl2.  */
16003                                                          return 175;
16004                                                        }
16005                                                    }
16006                                                }
16007                                              else
16008                                                {
16009                                                  if (((word >> 29) & 0x1) == 0)
16010                                                    {
16011                                                      if (((word >> 30) & 0x1) == 0)
16012                                                        {
16013                                                          /* 33222222222211111111110000000000
16014                                                             10987654321098765432109876543210
16015                                                             xxxxxxxxxx011110xxxxx1xx0111100x
16016                                                             fminnm.  */
16017                                                          return 836;
16018                                                        }
16019                                                      else
16020                                                        {
16021                                                          /* 33222222222211111111110000000000
16022                                                             10987654321098765432109876543210
16023                                                             xxxxxxxxxx011110xxxxx1xx0111101x
16024                                                             sqabs.  */
16025                                                          return 475;
16026                                                        }
16027                                                    }
16028                                                  else
16029                                                    {
16030                                                      /* 33222222222211111111110000000000
16031                                                         10987654321098765432109876543210
16032                                                         xxxxxxxxxx011110xxxxx1xx011111xx
16033                                                         sqneg.  */
16034                                                      return 504;
16035                                                    }
16036                                                }
16037                                            }
16038                                          else
16039                                            {
16040                                              if (((word >> 16) & 0x1) == 0)
16041                                                {
16042                                                  if (((word >> 19) & 0x1) == 0)
16043                                                    {
16044                                                      if (((word >> 20) & 0x1) == 0)
16045                                                        {
16046                                                          if (((word >> 29) & 0x1) == 0)
16047                                                            {
16048                                                              /* 33222222222211111111110000000000
16049                                                                 10987654321098765432109876543210
16050                                                                 xxxxxxxxxx0111110xx001xx0111x0xx
16051                                                                 fabs.  */
16052                                                              return 194;
16053                                                            }
16054                                                          else
16055                                                            {
16056                                                              /* 33222222222211111111110000000000
16057                                                                 10987654321098765432109876543210
16058                                                                 xxxxxxxxxx0111110xx001xx0111x1xx
16059                                                                 fneg.  */
16060                                                              return 243;
16061                                                            }
16062                                                        }
16063                                                      else
16064                                                        {
16065                                                          if (((word >> 23) & 0x1) == 0)
16066                                                            {
16067                                                              if (((word >> 28) & 0x1) == 0)
16068                                                                {
16069                                                                  if (((word >> 29) & 0x1) == 0)
16070                                                                    {
16071                                                                      /* 33222222222211111111110000000000
16072                                                                         10987654321098765432109876543210
16073                                                                         xxxxxxxxxx0111110xx011x0011100xx
16074                                                                         fmaxv.  */
16075                                                                      return 37;
16076                                                                    }
16077                                                                  else
16078                                                                    {
16079                                                                      /* 33222222222211111111110000000000
16080                                                                         10987654321098765432109876543210
16081                                                                         xxxxxxxxxx0111110xx011x0011101xx
16082                                                                         fmaxv.  */
16083                                                                      return 36;
16084                                                                    }
16085                                                                }
16086                                                              else
16087                                                                {
16088                                                                  if (((word >> 29) & 0x1) == 0)
16089                                                                    {
16090                                                                      /* 33222222222211111111110000000000
16091                                                                         10987654321098765432109876543210
16092                                                                         xxxxxxxxxx0111110xx011x0011110xx
16093                                                                         fmaxp.  */
16094                                                                      return 537;
16095                                                                    }
16096                                                                  else
16097                                                                    {
16098                                                                      /* 33222222222211111111110000000000
16099                                                                         10987654321098765432109876543210
16100                                                                         xxxxxxxxxx0111110xx011x0011111xx
16101                                                                         fmaxp.  */
16102                                                                      return 536;
16103                                                                    }
16104                                                                }
16105                                                            }
16106                                                          else
16107                                                            {
16108                                                              if (((word >> 28) & 0x1) == 0)
16109                                                                {
16110                                                                  if (((word >> 29) & 0x1) == 0)
16111                                                                    {
16112                                                                      /* 33222222222211111111110000000000
16113                                                                         10987654321098765432109876543210
16114                                                                         xxxxxxxxxx0111110xx011x1011100xx
16115                                                                         fminv.  */
16116                                                                      return 41;
16117                                                                    }
16118                                                                  else
16119                                                                    {
16120                                                                      /* 33222222222211111111110000000000
16121                                                                         10987654321098765432109876543210
16122                                                                         xxxxxxxxxx0111110xx011x1011101xx
16123                                                                         fminv.  */
16124                                                                      return 40;
16125                                                                    }
16126                                                                }
16127                                                              else
16128                                                                {
16129                                                                  if (((word >> 29) & 0x1) == 0)
16130                                                                    {
16131                                                                      /* 33222222222211111111110000000000
16132                                                                         10987654321098765432109876543210
16133                                                                         xxxxxxxxxx0111110xx011x1011110xx
16134                                                                         fminp.  */
16135                                                                      return 541;
16136                                                                    }
16137                                                                  else
16138                                                                    {
16139                                                                      /* 33222222222211111111110000000000
16140                                                                         10987654321098765432109876543210
16141                                                                         xxxxxxxxxx0111110xx011x1011111xx
16142                                                                         fminp.  */
16143                                                                      return 540;
16144                                                                    }
16145                                                                }
16146                                                            }
16147                                                        }
16148                                                    }
16149                                                  else
16150                                                    {
16151                                                      if (((word >> 29) & 0x1) == 0)
16152                                                        {
16153                                                          /* 33222222222211111111110000000000
16154                                                             10987654321098765432109876543210
16155                                                             xxxxxxxxxx0111110xx1x1xx0111x0xx
16156                                                             fabs.  */
16157                                                          return 195;
16158                                                        }
16159                                                      else
16160                                                        {
16161                                                          /* 33222222222211111111110000000000
16162                                                             10987654321098765432109876543210
16163                                                             xxxxxxxxxx0111110xx1x1xx0111x1xx
16164                                                             fneg.  */
16165                                                          return 244;
16166                                                        }
16167                                                    }
16168                                                }
16169                                              else
16170                                                {
16171                                                  if (((word >> 19) & 0x1) == 0)
16172                                                    {
16173                                                      if (((word >> 28) & 0x1) == 0)
16174                                                        {
16175                                                          /* 33222222222211111111110000000000
16176                                                             10987654321098765432109876543210
16177                                                             xxxxxxxxxx0111111xx0x1xx01110xxx
16178                                                             fsqrt.  */
16179                                                          return 254;
16180                                                        }
16181                                                      else
16182                                                        {
16183                                                          /* 33222222222211111111110000000000
16184                                                             10987654321098765432109876543210
16185                                                             xxxxxxxxxx0111111xx0x1xx01111xxx
16186                                                             frecpx.  */
16187                                                          return 501;
16188                                                        }
16189                                                    }
16190                                                  else
16191                                                    {
16192                                                      if (((word >> 28) & 0x1) == 0)
16193                                                        {
16194                                                          /* 33222222222211111111110000000000
16195                                                             10987654321098765432109876543210
16196                                                             xxxxxxxxxx0111111xx1x1xx01110xxx
16197                                                             fsqrt.  */
16198                                                          return 255;
16199                                                        }
16200                                                      else
16201                                                        {
16202                                                          /* 33222222222211111111110000000000
16203                                                             10987654321098765432109876543210
16204                                                             xxxxxxxxxx0111111xx1x1xx01111xxx
16205                                                             frecpx.  */
16206                                                          return 502;
16207                                                        }
16208                                                    }
16209                                                }
16210                                            }
16211                                        }
16212                                    }
16213                                }
16214                            }
16215                        }
16216                      else
16217                        {
16218                          if (((word >> 11) & 0x1) == 0)
16219                            {
16220                              if (((word >> 28) & 0x1) == 0)
16221                                {
16222                                  if (((word >> 12) & 0x1) == 0)
16223                                    {
16224                                      if (((word >> 13) & 0x1) == 0)
16225                                        {
16226                                          if (((word >> 14) & 0x1) == 0)
16227                                            {
16228                                              if (((word >> 15) & 0x1) == 0)
16229                                                {
16230                                                  if (((word >> 29) & 0x1) == 0)
16231                                                    {
16232                                                      /* 33222222222211111111110000000000
16233                                                         10987654321098765432109876543210
16234                                                         xxxxxxxxxx100000xxxxx1xx011100xx
16235                                                         shadd.  */
16236                                                      return 262;
16237                                                    }
16238                                                  else
16239                                                    {
16240                                                      /* 33222222222211111111110000000000
16241                                                         10987654321098765432109876543210
16242                                                         xxxxxxxxxx100000xxxxx1xx011101xx
16243                                                         uhadd.  */
16244                                                      return 314;
16245                                                    }
16246                                                }
16247                                              else
16248                                                {
16249                                                  if (((word >> 29) & 0x1) == 0)
16250                                                    {
16251                                                      /* 33222222222211111111110000000000
16252                                                         10987654321098765432109876543210
16253                                                         xxxxxxxxxx100001xxxxx1xx011100xx
16254                                                         add.  */
16255                                                      return 277;
16256                                                    }
16257                                                  else
16258                                                    {
16259                                                      /* 33222222222211111111110000000000
16260                                                         10987654321098765432109876543210
16261                                                         xxxxxxxxxx100001xxxxx1xx011101xx
16262                                                         sub.  */
16263                                                      return 329;
16264                                                    }
16265                                                }
16266                                            }
16267                                          else
16268                                            {
16269                                              if (((word >> 15) & 0x1) == 0)
16270                                                {
16271                                                  if (((word >> 29) & 0x1) == 0)
16272                                                    {
16273                                                      /* 33222222222211111111110000000000
16274                                                         10987654321098765432109876543210
16275                                                         xxxxxxxxxx100010xxxxx1xx011100xx
16276                                                         sshl.  */
16277                                                      return 269;
16278                                                    }
16279                                                  else
16280                                                    {
16281                                                      /* 33222222222211111111110000000000
16282                                                         10987654321098765432109876543210
16283                                                         xxxxxxxxxx100010xxxxx1xx011101xx
16284                                                         ushl.  */
16285                                                      return 321;
16286                                                    }
16287                                                }
16288                                              else
16289                                                {
16290                                                  if (((word >> 23) & 0x1) == 0)
16291                                                    {
16292                                                      if (((word >> 29) & 0x1) == 0)
16293                                                        {
16294                                                          /* 33222222222211111111110000000000
16295                                                             10987654321098765432109876543210
16296                                                             xxxxxxxxxx100011xxxxx1x0011100xx
16297                                                             fmaxnm.  */
16298                                                          return 285;
16299                                                        }
16300                                                      else
16301                                                        {
16302                                                          /* 33222222222211111111110000000000
16303                                                             10987654321098765432109876543210
16304                                                             xxxxxxxxxx100011xxxxx1x0011101xx
16305                                                             fmaxnmp.  */
16306                                                          return 336;
16307                                                        }
16308                                                    }
16309                                                  else
16310                                                    {
16311                                                      if (((word >> 29) & 0x1) == 0)
16312                                                        {
16313                                                          /* 33222222222211111111110000000000
16314                                                             10987654321098765432109876543210
16315                                                             xxxxxxxxxx100011xxxxx1x1011100xx
16316                                                             fminnm.  */
16317                                                          return 301;
16318                                                        }
16319                                                      else
16320                                                        {
16321                                                          /* 33222222222211111111110000000000
16322                                                             10987654321098765432109876543210
16323                                                             xxxxxxxxxx100011xxxxx1x1011101xx
16324                                                             fminnmp.  */
16325                                                          return 352;
16326                                                        }
16327                                                    }
16328                                                }
16329                                            }
16330                                        }
16331                                      else
16332                                        {
16333                                          if (((word >> 14) & 0x1) == 0)
16334                                            {
16335                                              if (((word >> 15) & 0x1) == 0)
16336                                                {
16337                                                  if (((word >> 29) & 0x1) == 0)
16338                                                    {
16339                                                      /* 33222222222211111111110000000000
16340                                                         10987654321098765432109876543210
16341                                                         xxxxxxxxxx100100xxxxx1xx011100xx
16342                                                         shsub.  */
16343                                                      return 265;
16344                                                    }
16345                                                  else
16346                                                    {
16347                                                      /* 33222222222211111111110000000000
16348                                                         10987654321098765432109876543210
16349                                                         xxxxxxxxxx100100xxxxx1xx011101xx
16350                                                         uhsub.  */
16351                                                      return 317;
16352                                                    }
16353                                                }
16354                                              else
16355                                                {
16356                                                  if (((word >> 29) & 0x1) == 0)
16357                                                    {
16358                                                      /* 33222222222211111111110000000000
16359                                                         10987654321098765432109876543210
16360                                                         xxxxxxxxxx100101xxxxx1xx011100xx
16361                                                         smaxp.  */
16362                                                      return 281;
16363                                                    }
16364                                                  else
16365                                                    {
16366                                                      /* 33222222222211111111110000000000
16367                                                         10987654321098765432109876543210
16368                                                         xxxxxxxxxx100101xxxxx1xx011101xx
16369                                                         umaxp.  */
16370                                                      return 333;
16371                                                    }
16372                                                }
16373                                            }
16374                                          else
16375                                            {
16376                                              if (((word >> 15) & 0x1) == 0)
16377                                                {
16378                                                  if (((word >> 29) & 0x1) == 0)
16379                                                    {
16380                                                      /* 33222222222211111111110000000000
16381                                                         10987654321098765432109876543210
16382                                                         xxxxxxxxxx100110xxxxx1xx011100xx
16383                                                         smax.  */
16384                                                      return 273;
16385                                                    }
16386                                                  else
16387                                                    {
16388                                                      /* 33222222222211111111110000000000
16389                                                         10987654321098765432109876543210
16390                                                         xxxxxxxxxx100110xxxxx1xx011101xx
16391                                                         umax.  */
16392                                                      return 325;
16393                                                    }
16394                                                }
16395                                              else
16396                                                {
16397                                                  if (((word >> 23) & 0x1) == 0)
16398                                                    {
16399                                                      if (((word >> 29) & 0x1) == 0)
16400                                                        {
16401                                                          /* 33222222222211111111110000000000
16402                                                             10987654321098765432109876543210
16403                                                             xxxxxxxxxx100111xxxxx1x0011100xx
16404                                                             fcmeq.  */
16405                                                          return 293;
16406                                                        }
16407                                                      else
16408                                                        {
16409                                                          /* 33222222222211111111110000000000
16410                                                             10987654321098765432109876543210
16411                                                             xxxxxxxxxx100111xxxxx1x0011101xx
16412                                                             fcmge.  */
16413                                                          return 342;
16414                                                        }
16415                                                    }
16416                                                  else
16417                                                    {
16418                                                      /* 33222222222211111111110000000000
16419                                                         10987654321098765432109876543210
16420                                                         xxxxxxxxxx100111xxxxx1x101110xxx
16421                                                         fcmgt.  */
16422                                                      return 356;
16423                                                    }
16424                                                }
16425                                            }
16426                                        }
16427                                    }
16428                                  else
16429                                    {
16430                                      if (((word >> 13) & 0x1) == 0)
16431                                        {
16432                                          if (((word >> 14) & 0x1) == 0)
16433                                            {
16434                                              if (((word >> 15) & 0x1) == 0)
16435                                                {
16436                                                  if (((word >> 29) & 0x1) == 0)
16437                                                    {
16438                                                      /* 33222222222211111111110000000000
16439                                                         10987654321098765432109876543210
16440                                                         xxxxxxxxxx101000xxxxx1xx011100xx
16441                                                         srhadd.  */
16442                                                      return 264;
16443                                                    }
16444                                                  else
16445                                                    {
16446                                                      /* 33222222222211111111110000000000
16447                                                         10987654321098765432109876543210
16448                                                         xxxxxxxxxx101000xxxxx1xx011101xx
16449                                                         urhadd.  */
16450                                                      return 316;
16451                                                    }
16452                                                }
16453                                              else
16454                                                {
16455                                                  if (((word >> 29) & 0x1) == 0)
16456                                                    {
16457                                                      /* 33222222222211111111110000000000
16458                                                         10987654321098765432109876543210
16459                                                         xxxxxxxxxx101001xxxxx1xx011100xx
16460                                                         mla.  */
16461                                                      return 279;
16462                                                    }
16463                                                  else
16464                                                    {
16465                                                      /* 33222222222211111111110000000000
16466                                                         10987654321098765432109876543210
16467                                                         xxxxxxxxxx101001xxxxx1xx011101xx
16468                                                         mls.  */
16469                                                      return 331;
16470                                                    }
16471                                                }
16472                                            }
16473                                          else
16474                                            {
16475                                              if (((word >> 15) & 0x1) == 0)
16476                                                {
16477                                                  if (((word >> 29) & 0x1) == 0)
16478                                                    {
16479                                                      /* 33222222222211111111110000000000
16480                                                         10987654321098765432109876543210
16481                                                         xxxxxxxxxx101010xxxxx1xx011100xx
16482                                                         srshl.  */
16483                                                      return 271;
16484                                                    }
16485                                                  else
16486                                                    {
16487                                                      /* 33222222222211111111110000000000
16488                                                         10987654321098765432109876543210
16489                                                         xxxxxxxxxx101010xxxxx1xx011101xx
16490                                                         urshl.  */
16491                                                      return 323;
16492                                                    }
16493                                                }
16494                                              else
16495                                                {
16496                                                  if (((word >> 23) & 0x1) == 0)
16497                                                    {
16498                                                      if (((word >> 29) & 0x1) == 0)
16499                                                        {
16500                                                          /* 33222222222211111111110000000000
16501                                                             10987654321098765432109876543210
16502                                                             xxxxxxxxxx101011xxxxx1x0011100xx
16503                                                             fadd.  */
16504                                                          return 289;
16505                                                        }
16506                                                      else
16507                                                        {
16508                                                          /* 33222222222211111111110000000000
16509                                                             10987654321098765432109876543210
16510                                                             xxxxxxxxxx101011xxxxx1x0011101xx
16511                                                             faddp.  */
16512                                                          return 338;
16513                                                        }
16514                                                    }
16515                                                  else
16516                                                    {
16517                                                      if (((word >> 29) & 0x1) == 0)
16518                                                        {
16519                                                          /* 33222222222211111111110000000000
16520                                                             10987654321098765432109876543210
16521                                                             xxxxxxxxxx101011xxxxx1x1011100xx
16522                                                             fsub.  */
16523                                                          return 305;
16524                                                        }
16525                                                      else
16526                                                        {
16527                                                          /* 33222222222211111111110000000000
16528                                                             10987654321098765432109876543210
16529                                                             xxxxxxxxxx101011xxxxx1x1011101xx
16530                                                             fabd.  */
16531                                                          return 354;
16532                                                        }
16533                                                    }
16534                                                }
16535                                            }
16536                                        }
16537                                      else
16538                                        {
16539                                          if (((word >> 14) & 0x1) == 0)
16540                                            {
16541                                              if (((word >> 15) & 0x1) == 0)
16542                                                {
16543                                                  if (((word >> 29) & 0x1) == 0)
16544                                                    {
16545                                                      /* 33222222222211111111110000000000
16546                                                         10987654321098765432109876543210
16547                                                         xxxxxxxxxx101100xxxxx1xx011100xx
16548                                                         cmgt.  */
16549                                                      return 267;
16550                                                    }
16551                                                  else
16552                                                    {
16553                                                      /* 33222222222211111111110000000000
16554                                                         10987654321098765432109876543210
16555                                                         xxxxxxxxxx101100xxxxx1xx011101xx
16556                                                         cmhi.  */
16557                                                      return 319;
16558                                                    }
16559                                                }
16560                                              else
16561                                                {
16562                                                  if (((word >> 29) & 0x1) == 0)
16563                                                    {
16564                                                      /* 33222222222211111111110000000000
16565                                                         10987654321098765432109876543210
16566                                                         xxxxxxxxxx101101xxxxx1xx011100xx
16567                                                         sqdmulh.  */
16568                                                      return 283;
16569                                                    }
16570                                                  else
16571                                                    {
16572                                                      /* 33222222222211111111110000000000
16573                                                         10987654321098765432109876543210
16574                                                         xxxxxxxxxx101101xxxxx1xx011101xx
16575                                                         sqrdmulh.  */
16576                                                      return 335;
16577                                                    }
16578                                                }
16579                                            }
16580                                          else
16581                                            {
16582                                              if (((word >> 15) & 0x1) == 0)
16583                                                {
16584                                                  if (((word >> 29) & 0x1) == 0)
16585                                                    {
16586                                                      /* 33222222222211111111110000000000
16587                                                         10987654321098765432109876543210
16588                                                         xxxxxxxxxx101110xxxxx1xx011100xx
16589                                                         sabd.  */
16590                                                      return 275;
16591                                                    }
16592                                                  else
16593                                                    {
16594                                                      /* 33222222222211111111110000000000
16595                                                         10987654321098765432109876543210
16596                                                         xxxxxxxxxx101110xxxxx1xx011101xx
16597                                                         uabd.  */
16598                                                      return 327;
16599                                                    }
16600                                                }
16601                                              else
16602                                                {
16603                                                  if (((word >> 23) & 0x1) == 0)
16604                                                    {
16605                                                      if (((word >> 29) & 0x1) == 0)
16606                                                        {
16607                                                          /* 33222222222211111111110000000000
16608                                                             10987654321098765432109876543210
16609                                                             xxxxxxxxxx101111xxxxx1x0011100xx
16610                                                             fmax.  */
16611                                                          return 295;
16612                                                        }
16613                                                      else
16614                                                        {
16615                                                          /* 33222222222211111111110000000000
16616                                                             10987654321098765432109876543210
16617                                                             xxxxxxxxxx101111xxxxx1x0011101xx
16618                                                             fmaxp.  */
16619                                                          return 346;
16620                                                        }
16621                                                    }
16622                                                  else
16623                                                    {
16624                                                      if (((word >> 29) & 0x1) == 0)
16625                                                        {
16626                                                          /* 33222222222211111111110000000000
16627                                                             10987654321098765432109876543210
16628                                                             xxxxxxxxxx101111xxxxx1x1011100xx
16629                                                             fmin.  */
16630                                                          return 307;
16631                                                        }
16632                                                      else
16633                                                        {
16634                                                          /* 33222222222211111111110000000000
16635                                                             10987654321098765432109876543210
16636                                                             xxxxxxxxxx101111xxxxx1x1011101xx
16637                                                             fminp.  */
16638                                                          return 360;
16639                                                        }
16640                                                    }
16641                                                }
16642                                            }
16643                                        }
16644                                    }
16645                                }
16646                              else
16647                                {
16648                                  if (((word >> 29) & 0x1) == 0)
16649                                    {
16650                                      if (((word >> 30) & 0x1) == 0)
16651                                        {
16652                                          if (((word >> 4) & 0x1) == 0)
16653                                            {
16654                                              /* 33222222222211111111110000000000
16655                                                 10987654321098765432109876543210
16656                                                 xxxx0xxxxx10xxxxxxxxx1xx0111100x
16657                                                 fccmp.  */
16658                                              return 787;
16659                                            }
16660                                          else
16661                                            {
16662                                              /* 33222222222211111111110000000000
16663                                                 10987654321098765432109876543210
16664                                                 xxxx1xxxxx10xxxxxxxxx1xx0111100x
16665                                                 fccmpe.  */
16666                                              return 789;
16667                                            }
16668                                        }
16669                                      else
16670                                        {
16671                                          if (((word >> 12) & 0x1) == 0)
16672                                            {
16673                                              if (((word >> 13) & 0x1) == 0)
16674                                                {
16675                                                  if (((word >> 14) & 0x1) == 0)
16676                                                    {
16677                                                      /* 33222222222211111111110000000000
16678                                                         10987654321098765432109876543210
16679                                                         xxxxxxxxxx10000xxxxxx1xx0111101x
16680                                                         add.  */
16681                                                      return 559;
16682                                                    }
16683                                                  else
16684                                                    {
16685                                                      /* 33222222222211111111110000000000
16686                                                         10987654321098765432109876543210
16687                                                         xxxxxxxxxx10001xxxxxx1xx0111101x
16688                                                         sshl.  */
16689                                                      return 557;
16690                                                    }
16691                                                }
16692                                              else
16693                                                {
16694                                                  /* 33222222222211111111110000000000
16695                                                     10987654321098765432109876543210
16696                                                     xxxxxxxxxx1001xxxxxxx1xx0111101x
16697                                                     fcmeq.  */
16698                                                  return 549;
16699                                                }
16700                                            }
16701                                          else
16702                                            {
16703                                              if (((word >> 13) & 0x1) == 0)
16704                                                {
16705                                                  /* 33222222222211111111110000000000
16706                                                     10987654321098765432109876543210
16707                                                     xxxxxxxxxx1010xxxxxxx1xx0111101x
16708                                                     srshl.  */
16709                                                  return 558;
16710                                                }
16711                                              else
16712                                                {
16713                                                  if (((word >> 15) & 0x1) == 0)
16714                                                    {
16715                                                      /* 33222222222211111111110000000000
16716                                                         10987654321098765432109876543210
16717                                                         xxxxxxxxxx1011x0xxxxx1xx0111101x
16718                                                         cmgt.  */
16719                                                      return 555;
16720                                                    }
16721                                                  else
16722                                                    {
16723                                                      /* 33222222222211111111110000000000
16724                                                         10987654321098765432109876543210
16725                                                         xxxxxxxxxx1011x1xxxxx1xx0111101x
16726                                                         sqdmulh.  */
16727                                                      return 546;
16728                                                    }
16729                                                }
16730                                            }
16731                                        }
16732                                    }
16733                                  else
16734                                    {
16735                                      if (((word >> 12) & 0x1) == 0)
16736                                        {
16737                                          if (((word >> 13) & 0x1) == 0)
16738                                            {
16739                                              if (((word >> 14) & 0x1) == 0)
16740                                                {
16741                                                  /* 33222222222211111111110000000000
16742                                                     10987654321098765432109876543210
16743                                                     xxxxxxxxxx10000xxxxxx1xx011111xx
16744                                                     sub.  */
16745                                                  return 580;
16746                                                }
16747                                              else
16748                                                {
16749                                                  /* 33222222222211111111110000000000
16750                                                     10987654321098765432109876543210
16751                                                     xxxxxxxxxx10001xxxxxx1xx011111xx
16752                                                     ushl.  */
16753                                                  return 578;
16754                                                }
16755                                            }
16756                                          else
16757                                            {
16758                                              if (((word >> 23) & 0x1) == 0)
16759                                                {
16760                                                  /* 33222222222211111111110000000000
16761                                                     10987654321098765432109876543210
16762                                                     xxxxxxxxxx1001xxxxxxx1x0011111xx
16763                                                     fcmge.  */
16764                                                  return 566;
16765                                                }
16766                                              else
16767                                                {
16768                                                  /* 33222222222211111111110000000000
16769                                                     10987654321098765432109876543210
16770                                                     xxxxxxxxxx1001xxxxxxx1x1011111xx
16771                                                     fcmgt.  */
16772                                                  return 572;
16773                                                }
16774                                            }
16775                                        }
16776                                      else
16777                                        {
16778                                          if (((word >> 13) & 0x1) == 0)
16779                                            {
16780                                              if (((word >> 15) & 0x1) == 0)
16781                                                {
16782                                                  /* 33222222222211111111110000000000
16783                                                     10987654321098765432109876543210
16784                                                     xxxxxxxxxx1010x0xxxxx1xx011111xx
16785                                                     urshl.  */
16786                                                  return 579;
16787                                                }
16788                                              else
16789                                                {
16790                                                  /* 33222222222211111111110000000000
16791                                                     10987654321098765432109876543210
16792                                                     xxxxxxxxxx1010x1xxxxx1xx011111xx
16793                                                     fabd.  */
16794                                                  return 570;
16795                                                }
16796                                            }
16797                                          else
16798                                            {
16799                                              if (((word >> 15) & 0x1) == 0)
16800                                                {
16801                                                  /* 33222222222211111111110000000000
16802                                                     10987654321098765432109876543210
16803                                                     xxxxxxxxxx1011x0xxxxx1xx011111xx
16804                                                     cmhi.  */
16805                                                  return 576;
16806                                                }
16807                                              else
16808                                                {
16809                                                  /* 33222222222211111111110000000000
16810                                                     10987654321098765432109876543210
16811                                                     xxxxxxxxxx1011x1xxxxx1xx011111xx
16812                                                     sqrdmulh.  */
16813                                                  return 565;
16814                                                }
16815                                            }
16816                                        }
16817                                    }
16818                                }
16819                            }
16820                          else
16821                            {
16822                              if (((word >> 28) & 0x1) == 0)
16823                                {
16824                                  if (((word >> 12) & 0x1) == 0)
16825                                    {
16826                                      if (((word >> 13) & 0x1) == 0)
16827                                        {
16828                                          if (((word >> 14) & 0x1) == 0)
16829                                            {
16830                                              if (((word >> 15) & 0x1) == 0)
16831                                                {
16832                                                  if (((word >> 29) & 0x1) == 0)
16833                                                    {
16834                                                      /* 33222222222211111111110000000000
16835                                                         10987654321098765432109876543210
16836                                                         xxxxxxxxxx110000xxxxx1xx011100xx
16837                                                         sqadd.  */
16838                                                      return 263;
16839                                                    }
16840                                                  else
16841                                                    {
16842                                                      /* 33222222222211111111110000000000
16843                                                         10987654321098765432109876543210
16844                                                         xxxxxxxxxx110000xxxxx1xx011101xx
16845                                                         uqadd.  */
16846                                                      return 315;
16847                                                    }
16848                                                }
16849                                              else
16850                                                {
16851                                                  if (((word >> 29) & 0x1) == 0)
16852                                                    {
16853                                                      /* 33222222222211111111110000000000
16854                                                         10987654321098765432109876543210
16855                                                         xxxxxxxxxx110001xxxxx1xx011100xx
16856                                                         cmtst.  */
16857                                                      return 278;
16858                                                    }
16859                                                  else
16860                                                    {
16861                                                      /* 33222222222211111111110000000000
16862                                                         10987654321098765432109876543210
16863                                                         xxxxxxxxxx110001xxxxx1xx011101xx
16864                                                         cmeq.  */
16865                                                      return 330;
16866                                                    }
16867                                                }
16868                                            }
16869                                          else
16870                                            {
16871                                              if (((word >> 15) & 0x1) == 0)
16872                                                {
16873                                                  if (((word >> 29) & 0x1) == 0)
16874                                                    {
16875                                                      /* 33222222222211111111110000000000
16876                                                         10987654321098765432109876543210
16877                                                         xxxxxxxxxx110010xxxxx1xx011100xx
16878                                                         sqshl.  */
16879                                                      return 270;
16880                                                    }
16881                                                  else
16882                                                    {
16883                                                      /* 33222222222211111111110000000000
16884                                                         10987654321098765432109876543210
16885                                                         xxxxxxxxxx110010xxxxx1xx011101xx
16886                                                         uqshl.  */
16887                                                      return 322;
16888                                                    }
16889                                                }
16890                                              else
16891                                                {
16892                                                  if (((word >> 23) & 0x1) == 0)
16893                                                    {
16894                                                      /* 33222222222211111111110000000000
16895                                                         10987654321098765432109876543210
16896                                                         xxxxxxxxxx110011xxxxx1x001110xxx
16897                                                         fmla.  */
16898                                                      return 287;
16899                                                    }
16900                                                  else
16901                                                    {
16902                                                      /* 33222222222211111111110000000000
16903                                                         10987654321098765432109876543210
16904                                                         xxxxxxxxxx110011xxxxx1x101110xxx
16905                                                         fmls.  */
16906                                                      return 303;
16907                                                    }
16908                                                }
16909                                            }
16910                                        }
16911                                      else
16912                                        {
16913                                          if (((word >> 14) & 0x1) == 0)
16914                                            {
16915                                              if (((word >> 15) & 0x1) == 0)
16916                                                {
16917                                                  if (((word >> 29) & 0x1) == 0)
16918                                                    {
16919                                                      /* 33222222222211111111110000000000
16920                                                         10987654321098765432109876543210
16921                                                         xxxxxxxxxx110100xxxxx1xx011100xx
16922                                                         sqsub.  */
16923                                                      return 266;
16924                                                    }
16925                                                  else
16926                                                    {
16927                                                      /* 33222222222211111111110000000000
16928                                                         10987654321098765432109876543210
16929                                                         xxxxxxxxxx110100xxxxx1xx011101xx
16930                                                         uqsub.  */
16931                                                      return 318;
16932                                                    }
16933                                                }
16934                                              else
16935                                                {
16936                                                  if (((word >> 29) & 0x1) == 0)
16937                                                    {
16938                                                      /* 33222222222211111111110000000000
16939                                                         10987654321098765432109876543210
16940                                                         xxxxxxxxxx110101xxxxx1xx011100xx
16941                                                         sminp.  */
16942                                                      return 282;
16943                                                    }
16944                                                  else
16945                                                    {
16946                                                      /* 33222222222211111111110000000000
16947                                                         10987654321098765432109876543210
16948                                                         xxxxxxxxxx110101xxxxx1xx011101xx
16949                                                         uminp.  */
16950                                                      return 334;
16951                                                    }
16952                                                }
16953                                            }
16954                                          else
16955                                            {
16956                                              if (((word >> 15) & 0x1) == 0)
16957                                                {
16958                                                  if (((word >> 29) & 0x1) == 0)
16959                                                    {
16960                                                      /* 33222222222211111111110000000000
16961                                                         10987654321098765432109876543210
16962                                                         xxxxxxxxxx110110xxxxx1xx011100xx
16963                                                         smin.  */
16964                                                      return 274;
16965                                                    }
16966                                                  else
16967                                                    {
16968                                                      /* 33222222222211111111110000000000
16969                                                         10987654321098765432109876543210
16970                                                         xxxxxxxxxx110110xxxxx1xx011101xx
16971                                                         umin.  */
16972                                                      return 326;
16973                                                    }
16974                                                }
16975                                              else
16976                                                {
16977                                                  if (((word >> 23) & 0x1) == 0)
16978                                                    {
16979                                                      /* 33222222222211111111110000000000
16980                                                         10987654321098765432109876543210
16981                                                         xxxxxxxxxx110111xxxxx1x001110xxx
16982                                                         facge.  */
16983                                                      return 344;
16984                                                    }
16985                                                  else
16986                                                    {
16987                                                      /* 33222222222211111111110000000000
16988                                                         10987654321098765432109876543210
16989                                                         xxxxxxxxxx110111xxxxx1x101110xxx
16990                                                         facgt.  */
16991                                                      return 358;
16992                                                    }
16993                                                }
16994                                            }
16995                                        }
16996                                    }
16997                                  else
16998                                    {
16999                                      if (((word >> 13) & 0x1) == 0)
17000                                        {
17001                                          if (((word >> 14) & 0x1) == 0)
17002                                            {
17003                                              if (((word >> 15) & 0x1) == 0)
17004                                                {
17005                                                  if (((word >> 22) & 0x1) == 0)
17006                                                    {
17007                                                      if (((word >> 23) & 0x1) == 0)
17008                                                        {
17009                                                          if (((word >> 29) & 0x1) == 0)
17010                                                            {
17011                                                              /* 33222222222211111111110000000000
17012                                                                 10987654321098765432109876543210
17013                                                                 xxxxxxxxxx111000xxxxx100011100xx
17014                                                                 and.  */
17015                                                              return 299;
17016                                                            }
17017                                                          else
17018                                                            {
17019                                                              /* 33222222222211111111110000000000
17020                                                                 10987654321098765432109876543210
17021                                                                 xxxxxxxxxx111000xxxxx100011101xx
17022                                                                 eor.  */
17023                                                              return 350;
17024                                                            }
17025                                                        }
17026                                                      else
17027                                                        {
17028                                                          if (((word >> 29) & 0x1) == 0)
17029                                                            {
17030                                                              /* 33222222222211111111110000000000
17031                                                                 10987654321098765432109876543210
17032                                                                 xxxxxxxxxx111000xxxxx101011100xx
17033                                                                 orr.  */
17034                                                              return 311;
17035                                                            }
17036                                                          else
17037                                                            {
17038                                                              /* 33222222222211111111110000000000
17039                                                                 10987654321098765432109876543210
17040                                                                 xxxxxxxxxx111000xxxxx101011101xx
17041                                                                 bit.  */
17042                                                              return 362;
17043                                                            }
17044                                                        }
17045                                                    }
17046                                                  else
17047                                                    {
17048                                                      if (((word >> 23) & 0x1) == 0)
17049                                                        {
17050                                                          if (((word >> 29) & 0x1) == 0)
17051                                                            {
17052                                                              /* 33222222222211111111110000000000
17053                                                                 10987654321098765432109876543210
17054                                                                 xxxxxxxxxx111000xxxxx110011100xx
17055                                                                 bic.  */
17056                                                              return 300;
17057                                                            }
17058                                                          else
17059                                                            {
17060                                                              /* 33222222222211111111110000000000
17061                                                                 10987654321098765432109876543210
17062                                                                 xxxxxxxxxx111000xxxxx110011101xx
17063                                                                 bsl.  */
17064                                                              return 351;
17065                                                            }
17066                                                        }
17067                                                      else
17068                                                        {
17069                                                          if (((word >> 29) & 0x1) == 0)
17070                                                            {
17071                                                              /* 33222222222211111111110000000000
17072                                                                 10987654321098765432109876543210
17073                                                                 xxxxxxxxxx111000xxxxx111011100xx
17074                                                                 orn.  */
17075                                                              return 313;
17076                                                            }
17077                                                          else
17078                                                            {
17079                                                              /* 33222222222211111111110000000000
17080                                                                 10987654321098765432109876543210
17081                                                                 xxxxxxxxxx111000xxxxx111011101xx
17082                                                                 bif.  */
17083                                                              return 363;
17084                                                            }
17085                                                        }
17086                                                    }
17087                                                }
17088                                              else
17089                                                {
17090                                                  if (((word >> 29) & 0x1) == 0)
17091                                                    {
17092                                                      /* 33222222222211111111110000000000
17093                                                         10987654321098765432109876543210
17094                                                         xxxxxxxxxx111001xxxxx1xx011100xx
17095                                                         mul.  */
17096                                                      return 280;
17097                                                    }
17098                                                  else
17099                                                    {
17100                                                      /* 33222222222211111111110000000000
17101                                                         10987654321098765432109876543210
17102                                                         xxxxxxxxxx111001xxxxx1xx011101xx
17103                                                         pmul.  */
17104                                                      return 332;
17105                                                    }
17106                                                }
17107                                            }
17108                                          else
17109                                            {
17110                                              if (((word >> 15) & 0x1) == 0)
17111                                                {
17112                                                  if (((word >> 29) & 0x1) == 0)
17113                                                    {
17114                                                      /* 33222222222211111111110000000000
17115                                                         10987654321098765432109876543210
17116                                                         xxxxxxxxxx111010xxxxx1xx011100xx
17117                                                         sqrshl.  */
17118                                                      return 272;
17119                                                    }
17120                                                  else
17121                                                    {
17122                                                      /* 33222222222211111111110000000000
17123                                                         10987654321098765432109876543210
17124                                                         xxxxxxxxxx111010xxxxx1xx011101xx
17125                                                         uqrshl.  */
17126                                                      return 324;
17127                                                    }
17128                                                }
17129                                              else
17130                                                {
17131                                                  if (((word >> 29) & 0x1) == 0)
17132                                                    {
17133                                                      /* 33222222222211111111110000000000
17134                                                         10987654321098765432109876543210
17135                                                         xxxxxxxxxx111011xxxxx1xx011100xx
17136                                                         fmulx.  */
17137                                                      return 291;
17138                                                    }
17139                                                  else
17140                                                    {
17141                                                      /* 33222222222211111111110000000000
17142                                                         10987654321098765432109876543210
17143                                                         xxxxxxxxxx111011xxxxx1xx011101xx
17144                                                         fmul.  */
17145                                                      return 340;
17146                                                    }
17147                                                }
17148                                            }
17149                                        }
17150                                      else
17151                                        {
17152                                          if (((word >> 14) & 0x1) == 0)
17153                                            {
17154                                              if (((word >> 15) & 0x1) == 0)
17155                                                {
17156                                                  if (((word >> 29) & 0x1) == 0)
17157                                                    {
17158                                                      /* 33222222222211111111110000000000
17159                                                         10987654321098765432109876543210
17160                                                         xxxxxxxxxx111100xxxxx1xx011100xx
17161                                                         cmge.  */
17162                                                      return 268;
17163                                                    }
17164                                                  else
17165                                                    {
17166                                                      /* 33222222222211111111110000000000
17167                                                         10987654321098765432109876543210
17168                                                         xxxxxxxxxx111100xxxxx1xx011101xx
17169                                                         cmhs.  */
17170                                                      return 320;
17171                                                    }
17172                                                }
17173                                              else
17174                                                {
17175                                                  /* 33222222222211111111110000000000
17176                                                     10987654321098765432109876543210
17177                                                     xxxxxxxxxx111101xxxxx1xx01110xxx
17178                                                     addp.  */
17179                                                  return 284;
17180                                                }
17181                                            }
17182                                          else
17183                                            {
17184                                              if (((word >> 15) & 0x1) == 0)
17185                                                {
17186                                                  if (((word >> 29) & 0x1) == 0)
17187                                                    {
17188                                                      /* 33222222222211111111110000000000
17189                                                         10987654321098765432109876543210
17190                                                         xxxxxxxxxx111110xxxxx1xx011100xx
17191                                                         saba.  */
17192                                                      return 276;
17193                                                    }
17194                                                  else
17195                                                    {
17196                                                      /* 33222222222211111111110000000000
17197                                                         10987654321098765432109876543210
17198                                                         xxxxxxxxxx111110xxxxx1xx011101xx
17199                                                         uaba.  */
17200                                                      return 328;
17201                                                    }
17202                                                }
17203                                              else
17204                                                {
17205                                                  if (((word >> 23) & 0x1) == 0)
17206                                                    {
17207                                                      if (((word >> 29) & 0x1) == 0)
17208                                                        {
17209                                                          /* 33222222222211111111110000000000
17210                                                             10987654321098765432109876543210
17211                                                             xxxxxxxxxx111111xxxxx1x0011100xx
17212                                                             frecps.  */
17213                                                          return 297;
17214                                                        }
17215                                                      else
17216                                                        {
17217                                                          /* 33222222222211111111110000000000
17218                                                             10987654321098765432109876543210
17219                                                             xxxxxxxxxx111111xxxxx1x0011101xx
17220                                                             fdiv.  */
17221                                                          return 348;
17222                                                        }
17223                                                    }
17224                                                  else
17225                                                    {
17226                                                      /* 33222222222211111111110000000000
17227                                                         10987654321098765432109876543210
17228                                                         xxxxxxxxxx111111xxxxx1x101110xxx
17229                                                         frsqrts.  */
17230                                                      return 309;
17231                                                    }
17232                                                }
17233                                            }
17234                                        }
17235                                    }
17236                                }
17237                              else
17238                                {
17239                                  if (((word >> 29) & 0x1) == 0)
17240                                    {
17241                                      if (((word >> 30) & 0x1) == 0)
17242                                        {
17243                                          /* 33222222222211111111110000000000
17244                                             10987654321098765432109876543210
17245                                             xxxxxxxxxx11xxxxxxxxx1xx0111100x
17246                                             fcsel.  */
17247                                          return 850;
17248                                        }
17249                                      else
17250                                        {
17251                                          if (((word >> 12) & 0x1) == 0)
17252                                            {
17253                                              if (((word >> 13) & 0x1) == 0)
17254                                                {
17255                                                  if (((word >> 14) & 0x1) == 0)
17256                                                    {
17257                                                      if (((word >> 15) & 0x1) == 0)
17258                                                        {
17259                                                          /* 33222222222211111111110000000000
17260                                                             10987654321098765432109876543210
17261                                                             xxxxxxxxxx110000xxxxx1xx0111101x
17262                                                             sqadd.  */
17263                                                          return 542;
17264                                                        }
17265                                                      else
17266                                                        {
17267                                                          /* 33222222222211111111110000000000
17268                                                             10987654321098765432109876543210
17269                                                             xxxxxxxxxx110001xxxxx1xx0111101x
17270                                                             cmtst.  */
17271                                                          return 560;
17272                                                        }
17273                                                    }
17274                                                  else
17275                                                    {
17276                                                      /* 33222222222211111111110000000000
17277                                                         10987654321098765432109876543210
17278                                                         xxxxxxxxxx11001xxxxxx1xx0111101x
17279                                                         sqshl.  */
17280                                                      return 544;
17281                                                    }
17282                                                }
17283                                              else
17284                                                {
17285                                                  /* 33222222222211111111110000000000
17286                                                     10987654321098765432109876543210
17287                                                     xxxxxxxxxx1101xxxxxxx1xx0111101x
17288                                                     sqsub.  */
17289                                                  return 543;
17290                                                }
17291                                            }
17292                                          else
17293                                            {
17294                                              if (((word >> 13) & 0x1) == 0)
17295                                                {
17296                                                  if (((word >> 15) & 0x1) == 0)
17297                                                    {
17298                                                      /* 33222222222211111111110000000000
17299                                                         10987654321098765432109876543210
17300                                                         xxxxxxxxxx1110x0xxxxx1xx0111101x
17301                                                         sqrshl.  */
17302                                                      return 545;
17303                                                    }
17304                                                  else
17305                                                    {
17306                                                      /* 33222222222211111111110000000000
17307                                                         10987654321098765432109876543210
17308                                                         xxxxxxxxxx1110x1xxxxx1xx0111101x
17309                                                         fmulx.  */
17310                                                      return 547;
17311                                                    }
17312                                                }
17313                                              else
17314                                                {
17315                                                  if (((word >> 14) & 0x1) == 0)
17316                                                    {
17317                                                      /* 33222222222211111111110000000000
17318                                                         10987654321098765432109876543210
17319                                                         xxxxxxxxxx11110xxxxxx1xx0111101x
17320                                                         cmge.  */
17321                                                      return 556;
17322                                                    }
17323                                                  else
17324                                                    {
17325                                                      if (((word >> 23) & 0x1) == 0)
17326                                                        {
17327                                                          /* 33222222222211111111110000000000
17328                                                             10987654321098765432109876543210
17329                                                             xxxxxxxxxx11111xxxxxx1x00111101x
17330                                                             frecps.  */
17331                                                          return 551;
17332                                                        }
17333                                                      else
17334                                                        {
17335                                                          /* 33222222222211111111110000000000
17336                                                             10987654321098765432109876543210
17337                                                             xxxxxxxxxx11111xxxxxx1x10111101x
17338                                                             frsqrts.  */
17339                                                          return 553;
17340                                                        }
17341                                                    }
17342                                                }
17343                                            }
17344                                        }
17345                                    }
17346                                  else
17347                                    {
17348                                      if (((word >> 12) & 0x1) == 0)
17349                                        {
17350                                          if (((word >> 13) & 0x1) == 0)
17351                                            {
17352                                              if (((word >> 14) & 0x1) == 0)
17353                                                {
17354                                                  if (((word >> 15) & 0x1) == 0)
17355                                                    {
17356                                                      /* 33222222222211111111110000000000
17357                                                         10987654321098765432109876543210
17358                                                         xxxxxxxxxx110000xxxxx1xx011111xx
17359                                                         uqadd.  */
17360                                                      return 561;
17361                                                    }
17362                                                  else
17363                                                    {
17364                                                      /* 33222222222211111111110000000000
17365                                                         10987654321098765432109876543210
17366                                                         xxxxxxxxxx110001xxxxx1xx011111xx
17367                                                         cmeq.  */
17368                                                      return 581;
17369                                                    }
17370                                                }
17371                                              else
17372                                                {
17373                                                  /* 33222222222211111111110000000000
17374                                                     10987654321098765432109876543210
17375                                                     xxxxxxxxxx11001xxxxxx1xx011111xx
17376                                                     uqshl.  */
17377                                                  return 563;
17378                                                }
17379                                            }
17380                                          else
17381                                            {
17382                                              if (((word >> 14) & 0x1) == 0)
17383                                                {
17384                                                  /* 33222222222211111111110000000000
17385                                                     10987654321098765432109876543210
17386                                                     xxxxxxxxxx11010xxxxxx1xx011111xx
17387                                                     uqsub.  */
17388                                                  return 562;
17389                                                }
17390                                              else
17391                                                {
17392                                                  if (((word >> 23) & 0x1) == 0)
17393                                                    {
17394                                                      /* 33222222222211111111110000000000
17395                                                         10987654321098765432109876543210
17396                                                         xxxxxxxxxx11011xxxxxx1x0011111xx
17397                                                         facge.  */
17398                                                      return 568;
17399                                                    }
17400                                                  else
17401                                                    {
17402                                                      /* 33222222222211111111110000000000
17403                                                         10987654321098765432109876543210
17404                                                         xxxxxxxxxx11011xxxxxx1x1011111xx
17405                                                         facgt.  */
17406                                                      return 574;
17407                                                    }
17408                                                }
17409                                            }
17410                                        }
17411                                      else
17412                                        {
17413                                          if (((word >> 13) & 0x1) == 0)
17414                                            {
17415                                              /* 33222222222211111111110000000000
17416                                                 10987654321098765432109876543210
17417                                                 xxxxxxxxxx1110xxxxxxx1xx011111xx
17418                                                 uqrshl.  */
17419                                              return 564;
17420                                            }
17421                                          else
17422                                            {
17423                                              /* 33222222222211111111110000000000
17424                                                 10987654321098765432109876543210
17425                                                 xxxxxxxxxx1111xxxxxxx1xx011111xx
17426                                                 cmhs.  */
17427                                              return 577;
17428                                            }
17429                                        }
17430                                    }
17431                                }
17432                            }
17433                        }
17434                    }
17435                }
17436              else
17437                {
17438                  if (((word >> 15) & 0x1) == 0)
17439                    {
17440                      if (((word >> 28) & 0x1) == 0)
17441                        {
17442                          if (((word >> 10) & 0x1) == 0)
17443                            {
17444                              if (((word >> 12) & 0x1) == 0)
17445                                {
17446                                  if (((word >> 13) & 0x1) == 0)
17447                                    {
17448                                      if (((word >> 14) & 0x1) == 0)
17449                                        {
17450                                          /* 33222222222211111111110000000000
17451                                             10987654321098765432109876543210
17452                                             xxxxxxxxxx0x0000xxxxxxxx11110xxx
17453                                             mla.  */
17454                                          return 117;
17455                                        }
17456                                      else
17457                                        {
17458                                          /* 33222222222211111111110000000000
17459                                             10987654321098765432109876543210
17460                                             xxxxxxxxxx0x0010xxxxxxxx11110xxx
17461                                             mls.  */
17462                                          return 120;
17463                                        }
17464                                    }
17465                                  else
17466                                    {
17467                                      if (((word >> 14) & 0x1) == 0)
17468                                        {
17469                                          if (((word >> 29) & 0x1) == 0)
17470                                            {
17471                                              if (((word >> 30) & 0x1) == 0)
17472                                                {
17473                                                  /* 33222222222211111111110000000000
17474                                                     10987654321098765432109876543210
17475                                                     xxxxxxxxxx0x0100xxxxxxxx1111000x
17476                                                     smlal.  */
17477                                                  return 96;
17478                                                }
17479                                              else
17480                                                {
17481                                                  /* 33222222222211111111110000000000
17482                                                     10987654321098765432109876543210
17483                                                     xxxxxxxxxx0x0100xxxxxxxx1111001x
17484                                                     smlal2.  */
17485                                                  return 97;
17486                                                }
17487                                            }
17488                                          else
17489                                            {
17490                                              if (((word >> 30) & 0x1) == 0)
17491                                                {
17492                                                  /* 33222222222211111111110000000000
17493                                                     10987654321098765432109876543210
17494                                                     xxxxxxxxxx0x0100xxxxxxxx1111010x
17495                                                     umlal.  */
17496                                                  return 118;
17497                                                }
17498                                              else
17499                                                {
17500                                                  /* 33222222222211111111110000000000
17501                                                     10987654321098765432109876543210
17502                                                     xxxxxxxxxx0x0100xxxxxxxx1111011x
17503                                                     umlal2.  */
17504                                                  return 119;
17505                                                }
17506                                            }
17507                                        }
17508                                      else
17509                                        {
17510                                          if (((word >> 29) & 0x1) == 0)
17511                                            {
17512                                              if (((word >> 30) & 0x1) == 0)
17513                                                {
17514                                                  /* 33222222222211111111110000000000
17515                                                     10987654321098765432109876543210
17516                                                     xxxxxxxxxx0x0110xxxxxxxx1111000x
17517                                                     smlsl.  */
17518                                                  return 100;
17519                                                }
17520                                              else
17521                                                {
17522                                                  /* 33222222222211111111110000000000
17523                                                     10987654321098765432109876543210
17524                                                     xxxxxxxxxx0x0110xxxxxxxx1111001x
17525                                                     smlsl2.  */
17526                                                  return 101;
17527                                                }
17528                                            }
17529                                          else
17530                                            {
17531                                              if (((word >> 30) & 0x1) == 0)
17532                                                {
17533                                                  /* 33222222222211111111110000000000
17534                                                     10987654321098765432109876543210
17535                                                     xxxxxxxxxx0x0110xxxxxxxx1111010x
17536                                                     umlsl.  */
17537                                                  return 121;
17538                                                }
17539                                              else
17540                                                {
17541                                                  /* 33222222222211111111110000000000
17542                                                     10987654321098765432109876543210
17543                                                     xxxxxxxxxx0x0110xxxxxxxx1111011x
17544                                                     umlsl2.  */
17545                                                  return 122;
17546                                                }
17547                                            }
17548                                        }
17549                                    }
17550                                }
17551                              else
17552                                {
17553                                  if (((word >> 29) & 0x1) == 0)
17554                                    {
17555                                      if (((word >> 13) & 0x1) == 0)
17556                                        {
17557                                          if (((word >> 14) & 0x1) == 0)
17558                                            {
17559                                              if (((word >> 23) & 0x1) == 0)
17560                                                {
17561                                                  /* 33222222222211111111110000000000
17562                                                     10987654321098765432109876543210
17563                                                     xxxxxxxxxx0x1000xxxxxxx0111100xx
17564                                                     fmla.  */
17565                                                  return 112;
17566                                                }
17567                                              else
17568                                                {
17569                                                  /* 33222222222211111111110000000000
17570                                                     10987654321098765432109876543210
17571                                                     xxxxxxxxxx0x1000xxxxxxx1111100xx
17572                                                     fmla.  */
17573                                                  return 111;
17574                                                }
17575                                            }
17576                                          else
17577                                            {
17578                                              if (((word >> 23) & 0x1) == 0)
17579                                                {
17580                                                  /* 33222222222211111111110000000000
17581                                                     10987654321098765432109876543210
17582                                                     xxxxxxxxxx0x1010xxxxxxx0111100xx
17583                                                     fmls.  */
17584                                                  return 114;
17585                                                }
17586                                              else
17587                                                {
17588                                                  /* 33222222222211111111110000000000
17589                                                     10987654321098765432109876543210
17590                                                     xxxxxxxxxx0x1010xxxxxxx1111100xx
17591                                                     fmls.  */
17592                                                  return 113;
17593                                                }
17594                                            }
17595                                        }
17596                                      else
17597                                        {
17598                                          if (((word >> 14) & 0x1) == 0)
17599                                            {
17600                                              if (((word >> 30) & 0x1) == 0)
17601                                                {
17602                                                  /* 33222222222211111111110000000000
17603                                                     10987654321098765432109876543210
17604                                                     xxxxxxxxxx0x1100xxxxxxxx1111000x
17605                                                     sqdmlal.  */
17606                                                  return 98;
17607                                                }
17608                                              else
17609                                                {
17610                                                  /* 33222222222211111111110000000000
17611                                                     10987654321098765432109876543210
17612                                                     xxxxxxxxxx0x1100xxxxxxxx1111001x
17613                                                     sqdmlal2.  */
17614                                                  return 99;
17615                                                }
17616                                            }
17617                                          else
17618                                            {
17619                                              if (((word >> 30) & 0x1) == 0)
17620                                                {
17621                                                  /* 33222222222211111111110000000000
17622                                                     10987654321098765432109876543210
17623                                                     xxxxxxxxxx0x1110xxxxxxxx1111000x
17624                                                     sqdmlsl.  */
17625                                                  return 102;
17626                                                }
17627                                              else
17628                                                {
17629                                                  /* 33222222222211111111110000000000
17630                                                     10987654321098765432109876543210
17631                                                     xxxxxxxxxx0x1110xxxxxxxx1111001x
17632                                                     sqdmlsl2.  */
17633                                                  return 103;
17634                                                }
17635                                            }
17636                                        }
17637                                    }
17638                                  else
17639                                    {
17640                                      /* 33222222222211111111110000000000
17641                                         10987654321098765432109876543210
17642                                         xxxxxxxxxx0x1xx0xxxxxxxx111101xx
17643                                         fcmla.  */
17644                                      return 129;
17645                                    }
17646                                }
17647                            }
17648                          else
17649                            {
17650                              if (((word >> 12) & 0x1) == 0)
17651                                {
17652                                  if (((word >> 29) & 0x1) == 0)
17653                                    {
17654                                      /* 33222222222211111111110000000000
17655                                         10987654321098765432109876543210
17656                                         xxxxxxxxxx1x0xx0xxxxxxxx111100xx
17657                                         movi.  */
17658                                      return 131;
17659                                    }
17660                                  else
17661                                    {
17662                                      /* 33222222222211111111110000000000
17663                                         10987654321098765432109876543210
17664                                         xxxxxxxxxx1x0xx0xxxxxxxx111101xx
17665                                         mvni.  */
17666                                      return 139;
17667                                    }
17668                                }
17669                              else
17670                                {
17671                                  if (((word >> 29) & 0x1) == 0)
17672                                    {
17673                                      /* 33222222222211111111110000000000
17674                                         10987654321098765432109876543210
17675                                         xxxxxxxxxx1x1xx0xxxxxxxx111100xx
17676                                         orr.  */
17677                                      return 132;
17678                                    }
17679                                  else
17680                                    {
17681                                      /* 33222222222211111111110000000000
17682                                         10987654321098765432109876543210
17683                                         xxxxxxxxxx1x1xx0xxxxxxxx111101xx
17684                                         bic.  */
17685                                      return 140;
17686                                    }
17687                                }
17688                            }
17689                        }
17690                      else
17691                        {
17692                          if (((word >> 29) & 0x1) == 0)
17693                            {
17694                              if (((word >> 30) & 0x1) == 0)
17695                                {
17696                                  if (((word >> 21) & 0x1) == 0)
17697                                    {
17698                                      /* 33222222222211111111110000000000
17699                                         10987654321098765432109876543210
17700                                         xxxxxxxxxxxxxxx0xxxxx0xx1111100x
17701                                         fmadd.  */
17702                                      return 840;
17703                                    }
17704                                  else
17705                                    {
17706                                      /* 33222222222211111111110000000000
17707                                         10987654321098765432109876543210
17708                                         xxxxxxxxxxxxxxx0xxxxx1xx1111100x
17709                                         fnmadd.  */
17710                                      return 844;
17711                                    }
17712                                }
17713                              else
17714                                {
17715                                  if (((word >> 10) & 0x1) == 0)
17716                                    {
17717                                      if (((word >> 13) & 0x1) == 0)
17718                                        {
17719                                          if (((word >> 14) & 0x1) == 0)
17720                                            {
17721                                              if (((word >> 23) & 0x1) == 0)
17722                                                {
17723                                                  /* 33222222222211111111110000000000
17724                                                     10987654321098765432109876543210
17725                                                     xxxxxxxxxx0xx000xxxxxxx01111101x
17726                                                     fmla.  */
17727                                                  return 425;
17728                                                }
17729                                              else
17730                                                {
17731                                                  /* 33222222222211111111110000000000
17732                                                     10987654321098765432109876543210
17733                                                     xxxxxxxxxx0xx000xxxxxxx11111101x
17734                                                     fmla.  */
17735                                                  return 424;
17736                                                }
17737                                            }
17738                                          else
17739                                            {
17740                                              if (((word >> 23) & 0x1) == 0)
17741                                                {
17742                                                  /* 33222222222211111111110000000000
17743                                                     10987654321098765432109876543210
17744                                                     xxxxxxxxxx0xx010xxxxxxx01111101x
17745                                                     fmls.  */
17746                                                  return 427;
17747                                                }
17748                                              else
17749                                                {
17750                                                  /* 33222222222211111111110000000000
17751                                                     10987654321098765432109876543210
17752                                                     xxxxxxxxxx0xx010xxxxxxx11111101x
17753                                                     fmls.  */
17754                                                  return 426;
17755                                                }
17756                                            }
17757                                        }
17758                                      else
17759                                        {
17760                                          if (((word >> 14) & 0x1) == 0)
17761                                            {
17762                                              /* 33222222222211111111110000000000
17763                                                 10987654321098765432109876543210
17764                                                 xxxxxxxxxx0xx100xxxxxxxx1111101x
17765                                                 sqdmlal.  */
17766                                              return 419;
17767                                            }
17768                                          else
17769                                            {
17770                                              /* 33222222222211111111110000000000
17771                                                 10987654321098765432109876543210
17772                                                 xxxxxxxxxx0xx110xxxxxxxx1111101x
17773                                                 sqdmlsl.  */
17774                                              return 420;
17775                                            }
17776                                        }
17777                                    }
17778                                  else
17779                                    {
17780                                      if (((word >> 12) & 0x1) == 0)
17781                                        {
17782                                          if (((word >> 13) & 0x1) == 0)
17783                                            {
17784                                              /* 33222222222211111111110000000000
17785                                                 10987654321098765432109876543210
17786                                                 xxxxxxxxxx1x00x0xxxxxxxx1111101x
17787                                                 sshr.  */
17788                                              return 584;
17789                                            }
17790                                          else
17791                                            {
17792                                              /* 33222222222211111111110000000000
17793                                                 10987654321098765432109876543210
17794                                                 xxxxxxxxxx1x01x0xxxxxxxx1111101x
17795                                                 srshr.  */
17796                                              return 586;
17797                                            }
17798                                        }
17799                                      else
17800                                        {
17801                                          if (((word >> 13) & 0x1) == 0)
17802                                            {
17803                                              if (((word >> 14) & 0x1) == 0)
17804                                                {
17805                                                  /* 33222222222211111111110000000000
17806                                                     10987654321098765432109876543210
17807                                                     xxxxxxxxxx1x1000xxxxxxxx1111101x
17808                                                     ssra.  */
17809                                                  return 585;
17810                                                }
17811                                              else
17812                                                {
17813                                                  /* 33222222222211111111110000000000
17814                                                     10987654321098765432109876543210
17815                                                     xxxxxxxxxx1x1010xxxxxxxx1111101x
17816                                                     shl.  */
17817                                                  return 588;
17818                                                }
17819                                            }
17820                                          else
17821                                            {
17822                                              if (((word >> 14) & 0x1) == 0)
17823                                                {
17824                                                  /* 33222222222211111111110000000000
17825                                                     10987654321098765432109876543210
17826                                                     xxxxxxxxxx1x1100xxxxxxxx1111101x
17827                                                     srsra.  */
17828                                                  return 587;
17829                                                }
17830                                              else
17831                                                {
17832                                                  /* 33222222222211111111110000000000
17833                                                     10987654321098765432109876543210
17834                                                     xxxxxxxxxx1x1110xxxxxxxx1111101x
17835                                                     sqshl.  */
17836                                                  return 589;
17837                                                }
17838                                            }
17839                                        }
17840                                    }
17841                                }
17842                            }
17843                          else
17844                            {
17845                              if (((word >> 12) & 0x1) == 0)
17846                                {
17847                                  if (((word >> 13) & 0x1) == 0)
17848                                    {
17849                                      if (((word >> 14) & 0x1) == 0)
17850                                        {
17851                                          /* 33222222222211111111110000000000
17852                                             10987654321098765432109876543210
17853                                             xxxxxxxxxxxx0000xxxxxxxx111111xx
17854                                             ushr.  */
17855                                          return 596;
17856                                        }
17857                                      else
17858                                        {
17859                                          /* 33222222222211111111110000000000
17860                                             10987654321098765432109876543210
17861                                             xxxxxxxxxxxx0010xxxxxxxx111111xx
17862                                             sri.  */
17863                                          return 600;
17864                                        }
17865                                    }
17866                                  else
17867                                    {
17868                                      if (((word >> 14) & 0x1) == 0)
17869                                        {
17870                                          /* 33222222222211111111110000000000
17871                                             10987654321098765432109876543210
17872                                             xxxxxxxxxxxx0100xxxxxxxx111111xx
17873                                             urshr.  */
17874                                          return 598;
17875                                        }
17876                                      else
17877                                        {
17878                                          /* 33222222222211111111110000000000
17879                                             10987654321098765432109876543210
17880                                             xxxxxxxxxxxx0110xxxxxxxx111111xx
17881                                             sqshlu.  */
17882                                          return 602;
17883                                        }
17884                                    }
17885                                }
17886                              else
17887                                {
17888                                  if (((word >> 13) & 0x1) == 0)
17889                                    {
17890                                      if (((word >> 14) & 0x1) == 0)
17891                                        {
17892                                          /* 33222222222211111111110000000000
17893                                             10987654321098765432109876543210
17894                                             xxxxxxxxxxxx1000xxxxxxxx111111xx
17895                                             usra.  */
17896                                          return 597;
17897                                        }
17898                                      else
17899                                        {
17900                                          /* 33222222222211111111110000000000
17901                                             10987654321098765432109876543210
17902                                             xxxxxxxxxxxx1010xxxxxxxx111111xx
17903                                             sli.  */
17904                                          return 601;
17905                                        }
17906                                    }
17907                                  else
17908                                    {
17909                                      if (((word >> 14) & 0x1) == 0)
17910                                        {
17911                                          /* 33222222222211111111110000000000
17912                                             10987654321098765432109876543210
17913                                             xxxxxxxxxxxx1100xxxxxxxx111111xx
17914                                             ursra.  */
17915                                          return 599;
17916                                        }
17917                                      else
17918                                        {
17919                                          /* 33222222222211111111110000000000
17920                                             10987654321098765432109876543210
17921                                             xxxxxxxxxxxx1110xxxxxxxx111111xx
17922                                             uqshl.  */
17923                                          return 603;
17924                                        }
17925                                    }
17926                                }
17927                            }
17928                        }
17929                    }
17930                  else
17931                    {
17932                      if (((word >> 28) & 0x1) == 0)
17933                        {
17934                          if (((word >> 10) & 0x1) == 0)
17935                            {
17936                              if (((word >> 12) & 0x1) == 0)
17937                                {
17938                                  if (((word >> 13) & 0x1) == 0)
17939                                    {
17940                                      if (((word >> 14) & 0x1) == 0)
17941                                        {
17942                                          /* 33222222222211111111110000000000
17943                                             10987654321098765432109876543210
17944                                             xxxxxxxxxx0x0001xxxxxxxx11110xxx
17945                                             mul.  */
17946                                          return 104;
17947                                        }
17948                                      else
17949                                        {
17950                                          /* 33222222222211111111110000000000
17951                                             10987654321098765432109876543210
17952                                             xxxxxxxxxx0x0011xxxxxxxx11110xxx
17953                                             sqdmulh.  */
17954                                          return 109;
17955                                        }
17956                                    }
17957                                  else
17958                                    {
17959                                      if (((word >> 29) & 0x1) == 0)
17960                                        {
17961                                          if (((word >> 30) & 0x1) == 0)
17962                                            {
17963                                              /* 33222222222211111111110000000000
17964                                                 10987654321098765432109876543210
17965                                                 xxxxxxxxxx0x01x1xxxxxxxx1111000x
17966                                                 smull.  */
17967                                              return 105;
17968                                            }
17969                                          else
17970                                            {
17971                                              /* 33222222222211111111110000000000
17972                                                 10987654321098765432109876543210
17973                                                 xxxxxxxxxx0x01x1xxxxxxxx1111001x
17974                                                 smull2.  */
17975                                              return 106;
17976                                            }
17977                                        }
17978                                      else
17979                                        {
17980                                          if (((word >> 30) & 0x1) == 0)
17981                                            {
17982                                              /* 33222222222211111111110000000000
17983                                                 10987654321098765432109876543210
17984                                                 xxxxxxxxxx0x01x1xxxxxxxx1111010x
17985                                                 umull.  */
17986                                              return 123;
17987                                            }
17988                                          else
17989                                            {
17990                                              /* 33222222222211111111110000000000
17991                                                 10987654321098765432109876543210
17992                                                 xxxxxxxxxx0x01x1xxxxxxxx1111011x
17993                                                 umull2.  */
17994                                              return 124;
17995                                            }
17996                                        }
17997                                    }
17998                                }
17999                              else
18000                                {
18001                                  if (((word >> 13) & 0x1) == 0)
18002                                    {
18003                                      if (((word >> 14) & 0x1) == 0)
18004                                        {
18005                                          if (((word >> 23) & 0x1) == 0)
18006                                            {
18007                                              if (((word >> 29) & 0x1) == 0)
18008                                                {
18009                                                  /* 33222222222211111111110000000000
18010                                                     10987654321098765432109876543210
18011                                                     xxxxxxxxxx0x1001xxxxxxx0111100xx
18012                                                     fmul.  */
18013                                                  return 116;
18014                                                }
18015                                              else
18016                                                {
18017                                                  /* 33222222222211111111110000000000
18018                                                     10987654321098765432109876543210
18019                                                     xxxxxxxxxx0x1001xxxxxxx0111101xx
18020                                                     fmulx.  */
18021                                                  return 126;
18022                                                }
18023                                            }
18024                                          else
18025                                            {
18026                                              if (((word >> 29) & 0x1) == 0)
18027                                                {
18028                                                  /* 33222222222211111111110000000000
18029                                                     10987654321098765432109876543210
18030                                                     xxxxxxxxxx0x1001xxxxxxx1111100xx
18031                                                     fmul.  */
18032                                                  return 115;
18033                                                }
18034                                              else
18035                                                {
18036                                                  /* 33222222222211111111110000000000
18037                                                     10987654321098765432109876543210
18038                                                     xxxxxxxxxx0x1001xxxxxxx1111101xx
18039                                                     fmulx.  */
18040                                                  return 125;
18041                                                }
18042                                            }
18043                                        }
18044                                      else
18045                                        {
18046                                          if (((word >> 29) & 0x1) == 0)
18047                                            {
18048                                              /* 33222222222211111111110000000000
18049                                                 10987654321098765432109876543210
18050                                                 xxxxxxxxxx0x1011xxxxxxxx111100xx
18051                                                 sqrdmulh.  */
18052                                              return 110;
18053                                            }
18054                                          else
18055                                            {
18056                                              /* 33222222222211111111110000000000
18057                                                 10987654321098765432109876543210
18058                                                 xxxxxxxxxx0x1011xxxxxxxx111101xx
18059                                                 sqrdmlah.  */
18060                                              return 127;
18061                                            }
18062                                        }
18063                                    }
18064                                  else
18065                                    {
18066                                      if (((word >> 14) & 0x1) == 0)
18067                                        {
18068                                          if (((word >> 30) & 0x1) == 0)
18069                                            {
18070                                              /* 33222222222211111111110000000000
18071                                                 10987654321098765432109876543210
18072                                                 xxxxxxxxxx0x1101xxxxxxxx11110x0x
18073                                                 sqdmull.  */
18074                                              return 107;
18075                                            }
18076                                          else
18077                                            {
18078                                              /* 33222222222211111111110000000000
18079                                                 10987654321098765432109876543210
18080                                                 xxxxxxxxxx0x1101xxxxxxxx11110x1x
18081                                                 sqdmull2.  */
18082                                              return 108;
18083                                            }
18084                                        }
18085                                      else
18086                                        {
18087                                          /* 33222222222211111111110000000000
18088                                             10987654321098765432109876543210
18089                                             xxxxxxxxxx0x1111xxxxxxxx11110xxx
18090                                             sqrdmlsh.  */
18091                                          return 128;
18092                                        }
18093                                    }
18094                                }
18095                            }
18096                          else
18097                            {
18098                              if (((word >> 11) & 0x1) == 0)
18099                                {
18100                                  if (((word >> 14) & 0x1) == 0)
18101                                    {
18102                                      if (((word >> 12) & 0x1) == 0)
18103                                        {
18104                                          if (((word >> 29) & 0x1) == 0)
18105                                            {
18106                                              /* 33222222222211111111110000000000
18107                                                 10987654321098765432109876543210
18108                                                 xxxxxxxxxx100x01xxxxxxxx111100xx
18109                                                 movi.  */
18110                                              return 133;
18111                                            }
18112                                          else
18113                                            {
18114                                              /* 33222222222211111111110000000000
18115                                                 10987654321098765432109876543210
18116                                                 xxxxxxxxxx100x01xxxxxxxx111101xx
18117                                                 mvni.  */
18118                                              return 141;
18119                                            }
18120                                        }
18121                                      else
18122                                        {
18123                                          if (((word >> 29) & 0x1) == 0)
18124                                            {
18125                                              /* 33222222222211111111110000000000
18126                                                 10987654321098765432109876543210
18127                                                 xxxxxxxxxx101x01xxxxxxxx111100xx
18128                                                 orr.  */
18129                                              return 134;
18130                                            }
18131                                          else
18132                                            {
18133                                              /* 33222222222211111111110000000000
18134                                                 10987654321098765432109876543210
18135                                                 xxxxxxxxxx101x01xxxxxxxx111101xx
18136                                                 bic.  */
18137                                              return 142;
18138                                            }
18139                                        }
18140                                    }
18141                                  else
18142                                    {
18143                                      if (((word >> 13) & 0x1) == 0)
18144                                        {
18145                                          if (((word >> 29) & 0x1) == 0)
18146                                            {
18147                                              /* 33222222222211111111110000000000
18148                                                 10987654321098765432109876543210
18149                                                 xxxxxxxxxx10x011xxxxxxxx111100xx
18150                                                 movi.  */
18151                                              return 135;
18152                                            }
18153                                          else
18154                                            {
18155                                              /* 33222222222211111111110000000000
18156                                                 10987654321098765432109876543210
18157                                                 xxxxxxxxxx10x011xxxxxxxx111101xx
18158                                                 mvni.  */
18159                                              return 143;
18160                                            }
18161                                        }
18162                                      else
18163                                        {
18164                                          if (((word >> 12) & 0x1) == 0)
18165                                            {
18166                                              if (((word >> 29) & 0x1) == 0)
18167                                                {
18168                                                  /* 33222222222211111111110000000000
18169                                                     10987654321098765432109876543210
18170                                                     xxxxxxxxxx100111xxxxxxxx111100xx
18171                                                     movi.  */
18172                                                  return 136;
18173                                                }
18174                                              else
18175                                                {
18176                                                  /* 33222222222211111111110000000000
18177                                                     10987654321098765432109876543210
18178                                                     xxxxxxxxxx100111xxxxxxxx111101xx
18179                                                     movi.  */
18180                                                  return 144;
18181                                                }
18182                                            }
18183                                          else
18184                                            {
18185                                              if (((word >> 29) & 0x1) == 0)
18186                                                {
18187                                                  /* 33222222222211111111110000000000
18188                                                     10987654321098765432109876543210
18189                                                     xxxxxxxxxx101111xxxxxxxx111100xx
18190                                                     fmov.  */
18191                                                  return 137;
18192                                                }
18193                                              else
18194                                                {
18195                                                  /* 33222222222211111111110000000000
18196                                                     10987654321098765432109876543210
18197                                                     xxxxxxxxxx101111xxxxxxxx111101xx
18198                                                     fmov.  */
18199                                                  return 146;
18200                                                }
18201                                            }
18202                                        }
18203                                    }
18204                                }
18205                              else
18206                                {
18207                                  if (((word >> 12) & 0x1) == 0)
18208                                    {
18209                                      if (((word >> 29) & 0x1) == 0)
18210                                        {
18211                                          if (((word >> 30) & 0x1) == 0)
18212                                            {
18213                                              /* 33222222222211111111110000000000
18214                                                 10987654321098765432109876543210
18215                                                 xxxxxxxxxx110xx1xxxxxxxx1111000x
18216                                                 rshrn.  */
18217                                              return 376;
18218                                            }
18219                                          else
18220                                            {
18221                                              /* 33222222222211111111110000000000
18222                                                 10987654321098765432109876543210
18223                                                 xxxxxxxxxx110xx1xxxxxxxx1111001x
18224                                                 rshrn2.  */
18225                                              return 377;
18226                                            }
18227                                        }
18228                                      else
18229                                        {
18230                                          if (((word >> 30) & 0x1) == 0)
18231                                            {
18232                                              /* 33222222222211111111110000000000
18233                                                 10987654321098765432109876543210
18234                                                 xxxxxxxxxx110xx1xxxxxxxx1111010x
18235                                                 sqrshrun.  */
18236                                              return 400;
18237                                            }
18238                                          else
18239                                            {
18240                                              /* 33222222222211111111110000000000
18241                                                 10987654321098765432109876543210
18242                                                 xxxxxxxxxx110xx1xxxxxxxx1111011x
18243                                                 sqrshrun2.  */
18244                                              return 401;
18245                                            }
18246                                        }
18247                                    }
18248                                  else
18249                                    {
18250                                      if (((word >> 13) & 0x1) == 0)
18251                                        {
18252                                          if (((word >> 29) & 0x1) == 0)
18253                                            {
18254                                              if (((word >> 30) & 0x1) == 0)
18255                                                {
18256                                                  /* 33222222222211111111110000000000
18257                                                     10987654321098765432109876543210
18258                                                     xxxxxxxxxx1110x1xxxxxxxx1111000x
18259                                                     sqrshrn.  */
18260                                                  return 380;
18261                                                }
18262                                              else
18263                                                {
18264                                                  /* 33222222222211111111110000000000
18265                                                     10987654321098765432109876543210
18266                                                     xxxxxxxxxx1110x1xxxxxxxx1111001x
18267                                                     sqrshrn2.  */
18268                                                  return 381;
18269                                                }
18270                                            }
18271                                          else
18272                                            {
18273                                              if (((word >> 30) & 0x1) == 0)
18274                                                {
18275                                                  /* 33222222222211111111110000000000
18276                                                     10987654321098765432109876543210
18277                                                     xxxxxxxxxx1110x1xxxxxxxx1111010x
18278                                                     uqrshrn.  */
18279                                                  return 404;
18280                                                }
18281                                              else
18282                                                {
18283                                                  /* 33222222222211111111110000000000
18284                                                     10987654321098765432109876543210
18285                                                     xxxxxxxxxx1110x1xxxxxxxx1111011x
18286                                                     uqrshrn2.  */
18287                                                  return 405;
18288                                                }
18289                                            }
18290                                        }
18291                                      else
18292                                        {
18293                                          if (((word >> 29) & 0x1) == 0)
18294                                            {
18295                                              /* 33222222222211111111110000000000
18296                                                 10987654321098765432109876543210
18297                                                 xxxxxxxxxx1111x1xxxxxxxx111100xx
18298                                                 fmov.  */
18299                                              return 138;
18300                                            }
18301                                          else
18302                                            {
18303                                              /* 33222222222211111111110000000000
18304                                                 10987654321098765432109876543210
18305                                                 xxxxxxxxxx1111x1xxxxxxxx111101xx
18306                                                 fcvtzu.  */
18307                                              return 412;
18308                                            }
18309                                        }
18310                                    }
18311                                }
18312                            }
18313                        }
18314                      else
18315                        {
18316                          if (((word >> 29) & 0x1) == 0)
18317                            {
18318                              if (((word >> 30) & 0x1) == 0)
18319                                {
18320                                  if (((word >> 21) & 0x1) == 0)
18321                                    {
18322                                      /* 33222222222211111111110000000000
18323                                         10987654321098765432109876543210
18324                                         xxxxxxxxxxxxxxx1xxxxx0xx1111100x
18325                                         fmsub.  */
18326                                      return 842;
18327                                    }
18328                                  else
18329                                    {
18330                                      /* 33222222222211111111110000000000
18331                                         10987654321098765432109876543210
18332                                         xxxxxxxxxxxxxxx1xxxxx1xx1111100x
18333                                         fnmsub.  */
18334                                      return 846;
18335                                    }
18336                                }
18337                              else
18338                                {
18339                                  if (((word >> 10) & 0x1) == 0)
18340                                    {
18341                                      if (((word >> 12) & 0x1) == 0)
18342                                        {
18343                                          /* 33222222222211111111110000000000
18344                                             10987654321098765432109876543210
18345                                             xxxxxxxxxx0x0xx1xxxxxxxx1111101x
18346                                             sqdmulh.  */
18347                                          return 422;
18348                                        }
18349                                      else
18350                                        {
18351                                          if (((word >> 13) & 0x1) == 0)
18352                                            {
18353                                              if (((word >> 14) & 0x1) == 0)
18354                                                {
18355                                                  if (((word >> 23) & 0x1) == 0)
18356                                                    {
18357                                                      /* 33222222222211111111110000000000
18358                                                         10987654321098765432109876543210
18359                                                         xxxxxxxxxx0x1001xxxxxxx01111101x
18360                                                         fmul.  */
18361                                                      return 429;
18362                                                    }
18363                                                  else
18364                                                    {
18365                                                      /* 33222222222211111111110000000000
18366                                                         10987654321098765432109876543210
18367                                                         xxxxxxxxxx0x1001xxxxxxx11111101x
18368                                                         fmul.  */
18369                                                      return 428;
18370                                                    }
18371                                                }
18372                                              else
18373                                                {
18374                                                  /* 33222222222211111111110000000000
18375                                                     10987654321098765432109876543210
18376                                                     xxxxxxxxxx0x1011xxxxxxxx1111101x
18377                                                     sqrdmulh.  */
18378                                                  return 423;
18379                                                }
18380                                            }
18381                                          else
18382                                            {
18383                                              /* 33222222222211111111110000000000
18384                                                 10987654321098765432109876543210
18385                                                 xxxxxxxxxx0x11x1xxxxxxxx1111101x
18386                                                 sqdmull.  */
18387                                              return 421;
18388                                            }
18389                                        }
18390                                    }
18391                                  else
18392                                    {
18393                                      if (((word >> 11) & 0x1) == 0)
18394                                        {
18395                                          if (((word >> 12) & 0x1) == 0)
18396                                            {
18397                                              /* 33222222222211111111110000000000
18398                                                 10987654321098765432109876543210
18399                                                 xxxxxxxxxx100xx1xxxxxxxx1111101x
18400                                                 scvtf.  */
18401                                              return 592;
18402                                            }
18403                                          else
18404                                            {
18405                                              /* 33222222222211111111110000000000
18406                                                 10987654321098765432109876543210
18407                                                 xxxxxxxxxx101xx1xxxxxxxx1111101x
18408                                                 sqshrn.  */
18409                                              return 590;
18410                                            }
18411                                        }
18412                                      else
18413                                        {
18414                                          if (((word >> 13) & 0x1) == 0)
18415                                            {
18416                                              /* 33222222222211111111110000000000
18417                                                 10987654321098765432109876543210
18418                                                 xxxxxxxxxx11x0x1xxxxxxxx1111101x
18419                                                 sqrshrn.  */
18420                                              return 591;
18421                                            }
18422                                          else
18423                                            {
18424                                              /* 33222222222211111111110000000000
18425                                                 10987654321098765432109876543210
18426                                                 xxxxxxxxxx11x1x1xxxxxxxx1111101x
18427                                                 fcvtzs.  */
18428                                              return 594;
18429                                            }
18430                                        }
18431                                    }
18432                                }
18433                            }
18434                          else
18435                            {
18436                              if (((word >> 10) & 0x1) == 0)
18437                                {
18438                                  if (((word >> 13) & 0x1) == 0)
18439                                    {
18440                                      if (((word >> 14) & 0x1) == 0)
18441                                        {
18442                                          if (((word >> 23) & 0x1) == 0)
18443                                            {
18444                                              /* 33222222222211111111110000000000
18445                                                 10987654321098765432109876543210
18446                                                 xxxxxxxxxx0xx001xxxxxxx0111111xx
18447                                                 fmulx.  */
18448                                              return 431;
18449                                            }
18450                                          else
18451                                            {
18452                                              /* 33222222222211111111110000000000
18453                                                 10987654321098765432109876543210
18454                                                 xxxxxxxxxx0xx001xxxxxxx1111111xx
18455                                                 fmulx.  */
18456                                              return 430;
18457                                            }
18458                                        }
18459                                      else
18460                                        {
18461                                          /* 33222222222211111111110000000000
18462                                             10987654321098765432109876543210
18463                                             xxxxxxxxxx0xx011xxxxxxxx111111xx
18464                                             sqrdmlah.  */
18465                                          return 432;
18466                                        }
18467                                    }
18468                                  else
18469                                    {
18470                                      /* 33222222222211111111110000000000
18471                                         10987654321098765432109876543210
18472                                         xxxxxxxxxx0xx1x1xxxxxxxx111111xx
18473                                         sqrdmlsh.  */
18474                                      return 433;
18475                                    }
18476                                }
18477                              else
18478                                {
18479                                  if (((word >> 11) & 0x1) == 0)
18480                                    {
18481                                      if (((word >> 12) & 0x1) == 0)
18482                                        {
18483                                          if (((word >> 13) & 0x1) == 0)
18484                                            {
18485                                              /* 33222222222211111111110000000000
18486                                                 10987654321098765432109876543210
18487                                                 xxxxxxxxxx1000x1xxxxxxxx111111xx
18488                                                 sqshrun.  */
18489                                              return 604;
18490                                            }
18491                                          else
18492                                            {
18493                                              /* 33222222222211111111110000000000
18494                                                 10987654321098765432109876543210
18495                                                 xxxxxxxxxx1001x1xxxxxxxx111111xx
18496                                                 ucvtf.  */
18497                                              return 608;
18498                                            }
18499                                        }
18500                                      else
18501                                        {
18502                                          /* 33222222222211111111110000000000
18503                                             10987654321098765432109876543210
18504                                             xxxxxxxxxx101xx1xxxxxxxx111111xx
18505                                             uqshrn.  */
18506                                          return 606;
18507                                        }
18508                                    }
18509                                  else
18510                                    {
18511                                      if (((word >> 12) & 0x1) == 0)
18512                                        {
18513                                          /* 33222222222211111111110000000000
18514                                             10987654321098765432109876543210
18515                                             xxxxxxxxxx110xx1xxxxxxxx111111xx
18516                                             sqrshrun.  */
18517                                          return 605;
18518                                        }
18519                                      else
18520                                        {
18521                                          if (((word >> 13) & 0x1) == 0)
18522                                            {
18523                                              /* 33222222222211111111110000000000
18524                                                 10987654321098765432109876543210
18525                                                 xxxxxxxxxx1110x1xxxxxxxx111111xx
18526                                                 uqrshrn.  */
18527                                              return 607;
18528                                            }
18529                                          else
18530                                            {
18531                                              /* 33222222222211111111110000000000
18532                                                 10987654321098765432109876543210
18533                                                 xxxxxxxxxx1111x1xxxxxxxx111111xx
18534                                                 fcvtzu.  */
18535                                              return 610;
18536                                            }
18537                                        }
18538                                    }
18539                                }
18540                            }
18541                        }
18542                    }
18543                }
18544            }
18545        }
18546    }
18547}
18548
18549/* Lookup opcode WORD in the opcode table.  N.B. all alias
18550   opcodes are ignored here.  */
18551
18552const aarch64_opcode *
18553aarch64_opcode_lookup (uint32_t word)
18554{
18555  return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
18556}
18557
18558const aarch64_opcode *
18559aarch64_find_next_opcode (const aarch64_opcode *opcode)
18560{
18561  /* Use the index as the key to locate the next opcode.  */
18562  int key = opcode - aarch64_opcode_table;
18563  int value;
18564  switch (key)
18565    {
18566    case 941: value = 945; break;	/* stnp --> stp.  */
18567    case 945: return NULL;		/* stp --> NULL.  */
18568    case 939: value = 940; break;	/* stllrb --> stllrh.  */
18569    case 940: return NULL;		/* stllrh --> NULL.  */
18570    case 942: value = 946; break;	/* ldnp --> ldp.  */
18571    case 946: return NULL;		/* ldp --> NULL.  */
18572    case 1157: value = 1158; break;	/* msr --> hint.  */
18573    case 1158: value = 1172; break;	/* hint --> clrex.  */
18574    case 1172: value = 1173; break;	/* clrex --> dsb.  */
18575    case 1173: value = 1174; break;	/* dsb --> dmb.  */
18576    case 1174: value = 1175; break;	/* dmb --> isb.  */
18577    case 1175: value = 1176; break;	/* isb --> sys.  */
18578    case 1176: value = 1181; break;	/* sys --> msr.  */
18579    case 1181: return NULL;		/* msr --> NULL.  */
18580    case 1182: value = 1183; break;	/* sysl --> mrs.  */
18581    case 1183: return NULL;		/* mrs --> NULL.  */
18582    case 434: value = 435; break;	/* st4 --> st1.  */
18583    case 435: value = 436; break;	/* st1 --> st2.  */
18584    case 436: value = 437; break;	/* st2 --> st3.  */
18585    case 437: return NULL;		/* st3 --> NULL.  */
18586    case 442: value = 443; break;	/* st4 --> st1.  */
18587    case 443: value = 444; break;	/* st1 --> st2.  */
18588    case 444: value = 445; break;	/* st2 --> st3.  */
18589    case 445: return NULL;		/* st3 --> NULL.  */
18590    case 438: value = 439; break;	/* ld4 --> ld1.  */
18591    case 439: value = 440; break;	/* ld1 --> ld2.  */
18592    case 440: value = 441; break;	/* ld2 --> ld3.  */
18593    case 441: return NULL;		/* ld3 --> NULL.  */
18594    case 454: value = 456; break;	/* ld1 --> ld1r.  */
18595    case 456: return NULL;		/* ld1r --> NULL.  */
18596    case 458: value = 460; break;	/* ld2 --> ld2r.  */
18597    case 460: return NULL;		/* ld2r --> NULL.  */
18598    case 455: value = 457; break;	/* ld3 --> ld3r.  */
18599    case 457: return NULL;		/* ld3r --> NULL.  */
18600    case 459: value = 461; break;	/* ld4 --> ld4r.  */
18601    case 461: return NULL;		/* ld4r --> NULL.  */
18602    case 446: value = 447; break;	/* ld4 --> ld1.  */
18603    case 447: value = 448; break;	/* ld1 --> ld2.  */
18604    case 448: value = 449; break;	/* ld2 --> ld3.  */
18605    case 449: return NULL;		/* ld3 --> NULL.  */
18606    case 466: value = 468; break;	/* ld1 --> ld1r.  */
18607    case 468: return NULL;		/* ld1r --> NULL.  */
18608    case 467: value = 469; break;	/* ld3 --> ld3r.  */
18609    case 469: return NULL;		/* ld3r --> NULL.  */
18610    case 470: value = 472; break;	/* ld2 --> ld2r.  */
18611    case 472: return NULL;		/* ld2r --> NULL.  */
18612    case 471: value = 473; break;	/* ld4 --> ld4r.  */
18613    case 473: return NULL;		/* ld4r --> NULL.  */
18614    case 752: value = 753; break;	/* fcvtzs --> fcvtzs.  */
18615    case 753: return NULL;		/* fcvtzs --> NULL.  */
18616    case 748: value = 749; break;	/* scvtf --> scvtf.  */
18617    case 749: return NULL;		/* scvtf --> NULL.  */
18618    case 754: value = 755; break;	/* fcvtzu --> fcvtzu.  */
18619    case 755: return NULL;		/* fcvtzu --> NULL.  */
18620    case 750: value = 751; break;	/* ucvtf --> ucvtf.  */
18621    case 751: return NULL;		/* ucvtf --> NULL.  */
18622    case 756: value = 757; break;	/* fcvtns --> fcvtns.  */
18623    case 757: return NULL;		/* fcvtns --> NULL.  */
18624    case 776: value = 777; break;	/* fcvtms --> fcvtms.  */
18625    case 777: return NULL;		/* fcvtms --> NULL.  */
18626    case 772: value = 773; break;	/* fcvtps --> fcvtps.  */
18627    case 773: return NULL;		/* fcvtps --> NULL.  */
18628    case 780: value = 781; break;	/* fcvtzs --> fcvtzs.  */
18629    case 781: return NULL;		/* fcvtzs --> NULL.  */
18630    case 764: value = 765; break;	/* fcvtas --> fcvtas.  */
18631    case 765: return NULL;		/* fcvtas --> NULL.  */
18632    case 760: value = 761; break;	/* scvtf --> scvtf.  */
18633    case 761: return NULL;		/* scvtf --> NULL.  */
18634    case 768: value = 769; break;	/* fmov --> fmov.  */
18635    case 769: return NULL;		/* fmov --> NULL.  */
18636    case 758: value = 759; break;	/* fcvtnu --> fcvtnu.  */
18637    case 759: return NULL;		/* fcvtnu --> NULL.  */
18638    case 778: value = 779; break;	/* fcvtmu --> fcvtmu.  */
18639    case 779: return NULL;		/* fcvtmu --> NULL.  */
18640    case 774: value = 775; break;	/* fcvtpu --> fcvtpu.  */
18641    case 775: return NULL;		/* fcvtpu --> NULL.  */
18642    case 782: value = 783; break;	/* fcvtzu --> fcvtzu.  */
18643    case 783: return NULL;		/* fcvtzu --> NULL.  */
18644    case 766: value = 767; break;	/* fcvtau --> fcvtau.  */
18645    case 767: return NULL;		/* fcvtau --> NULL.  */
18646    case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
18647    case 763: return NULL;		/* ucvtf --> NULL.  */
18648    case 770: value = 771; break;	/* fmov --> fmov.  */
18649    case 771: return NULL;		/* fmov --> NULL.  */
18650    case 799: value = 800; break;	/* fmov --> fmov.  */
18651    case 800: return NULL;		/* fmov --> NULL.  */
18652    case 808: value = 809; break;	/* frintn --> frintn.  */
18653    case 809: return NULL;		/* frintn --> NULL.  */
18654    case 803: value = 804; break;	/* fneg --> fneg.  */
18655    case 804: return NULL;		/* fneg --> NULL.  */
18656    case 812: value = 813; break;	/* frintm --> frintm.  */
18657    case 813: return NULL;		/* frintm --> NULL.  */
18658    case 801: value = 802; break;	/* fabs --> fabs.  */
18659    case 802: return NULL;		/* fabs --> NULL.  */
18660    case 810: value = 811; break;	/* frintp --> frintp.  */
18661    case 811: return NULL;		/* frintp --> NULL.  */
18662    case 805: value = 806; break;	/* fsqrt --> fsqrt.  */
18663    case 806: return NULL;		/* fsqrt --> NULL.  */
18664    case 814: value = 815; break;	/* frintz --> frintz.  */
18665    case 815: return NULL;		/* frintz --> NULL.  */
18666    case 816: value = 817; break;	/* frinta --> frinta.  */
18667    case 817: return NULL;		/* frinta --> NULL.  */
18668    case 818: value = 819; break;	/* frintx --> frintx.  */
18669    case 819: return NULL;		/* frintx --> NULL.  */
18670    case 820: value = 821; break;	/* frinti --> frinti.  */
18671    case 821: return NULL;		/* frinti --> NULL.  */
18672    case 791: value = 792; break;	/* fcmp --> fcmp.  */
18673    case 792: return NULL;		/* fcmp --> NULL.  */
18674    case 793: value = 794; break;	/* fcmpe --> fcmpe.  */
18675    case 794: return NULL;		/* fcmpe --> NULL.  */
18676    case 795: value = 796; break;	/* fcmp --> fcmp.  */
18677    case 796: return NULL;		/* fcmp --> NULL.  */
18678    case 797: value = 798; break;	/* fcmpe --> fcmpe.  */
18679    case 798: return NULL;		/* fcmpe --> NULL.  */
18680    case 848: value = 849; break;	/* fmov --> fmov.  */
18681    case 849: return NULL;		/* fmov --> NULL.  */
18682    case 822: value = 823; break;	/* fmul --> fmul.  */
18683    case 823: return NULL;		/* fmul --> NULL.  */
18684    case 838: value = 839; break;	/* fnmul --> fnmul.  */
18685    case 839: return NULL;		/* fnmul --> NULL.  */
18686    case 830: value = 831; break;	/* fmax --> fmax.  */
18687    case 831: return NULL;		/* fmax --> NULL.  */
18688    case 826: value = 827; break;	/* fadd --> fadd.  */
18689    case 827: return NULL;		/* fadd --> NULL.  */
18690    case 834: value = 835; break;	/* fmaxnm --> fmaxnm.  */
18691    case 835: return NULL;		/* fmaxnm --> NULL.  */
18692    case 824: value = 825; break;	/* fdiv --> fdiv.  */
18693    case 825: return NULL;		/* fdiv --> NULL.  */
18694    case 832: value = 833; break;	/* fmin --> fmin.  */
18695    case 833: return NULL;		/* fmin --> NULL.  */
18696    case 828: value = 829; break;	/* fsub --> fsub.  */
18697    case 829: return NULL;		/* fsub --> NULL.  */
18698    case 836: value = 837; break;	/* fminnm --> fminnm.  */
18699    case 837: return NULL;		/* fminnm --> NULL.  */
18700    case 787: value = 788; break;	/* fccmp --> fccmp.  */
18701    case 788: return NULL;		/* fccmp --> NULL.  */
18702    case 789: value = 790; break;	/* fccmpe --> fccmpe.  */
18703    case 790: return NULL;		/* fccmpe --> NULL.  */
18704    case 850: value = 851; break;	/* fcsel --> fcsel.  */
18705    case 851: return NULL;		/* fcsel --> NULL.  */
18706    case 131: value = 368; break;	/* movi --> sshr.  */
18707    case 368: value = 370; break;	/* sshr --> srshr.  */
18708    case 370: return NULL;		/* srshr --> NULL.  */
18709    case 139: value = 390; break;	/* mvni --> ushr.  */
18710    case 390: value = 392; break;	/* ushr --> urshr.  */
18711    case 392: value = 394; break;	/* urshr --> sri.  */
18712    case 394: value = 396; break;	/* sri --> sqshlu.  */
18713    case 396: return NULL;		/* sqshlu --> NULL.  */
18714    case 132: value = 369; break;	/* orr --> ssra.  */
18715    case 369: value = 371; break;	/* ssra --> srsra.  */
18716    case 371: value = 372; break;	/* srsra --> shl.  */
18717    case 372: value = 373; break;	/* shl --> sqshl.  */
18718    case 373: return NULL;		/* sqshl --> NULL.  */
18719    case 140: value = 391; break;	/* bic --> usra.  */
18720    case 391: value = 393; break;	/* usra --> ursra.  */
18721    case 393: value = 395; break;	/* ursra --> sli.  */
18722    case 395: value = 397; break;	/* sli --> uqshl.  */
18723    case 397: return NULL;		/* uqshl --> NULL.  */
18724    case 840: value = 841; break;	/* fmadd --> fmadd.  */
18725    case 841: return NULL;		/* fmadd --> NULL.  */
18726    case 844: value = 845; break;	/* fnmadd --> fnmadd.  */
18727    case 845: return NULL;		/* fnmadd --> NULL.  */
18728    case 133: value = 374; break;	/* movi --> shrn.  */
18729    case 374: value = 375; break;	/* shrn --> shrn2.  */
18730    case 375: value = 382; break;	/* shrn2 --> sshll.  */
18731    case 382: value = 384; break;	/* sshll --> sshll2.  */
18732    case 384: return NULL;		/* sshll2 --> NULL.  */
18733    case 141: value = 398; break;	/* mvni --> sqshrun.  */
18734    case 398: value = 399; break;	/* sqshrun --> sqshrun2.  */
18735    case 399: value = 406; break;	/* sqshrun2 --> ushll.  */
18736    case 406: value = 408; break;	/* ushll --> ushll2.  */
18737    case 408: return NULL;		/* ushll2 --> NULL.  */
18738    case 134: value = 378; break;	/* orr --> sqshrn.  */
18739    case 378: value = 379; break;	/* sqshrn --> sqshrn2.  */
18740    case 379: return NULL;		/* sqshrn2 --> NULL.  */
18741    case 142: value = 402; break;	/* bic --> uqshrn.  */
18742    case 402: value = 403; break;	/* uqshrn --> uqshrn2.  */
18743    case 403: return NULL;		/* uqshrn2 --> NULL.  */
18744    case 136: value = 386; break;	/* movi --> scvtf.  */
18745    case 386: value = 387; break;	/* scvtf --> scvtf.  */
18746    case 387: return NULL;		/* scvtf --> NULL.  */
18747    case 144: value = 145; break;	/* movi --> movi.  */
18748    case 145: value = 410; break;	/* movi --> ucvtf.  */
18749    case 410: value = 411; break;	/* ucvtf --> ucvtf.  */
18750    case 411: return NULL;		/* ucvtf --> NULL.  */
18751    case 138: value = 388; break;	/* fmov --> fcvtzs.  */
18752    case 388: value = 389; break;	/* fcvtzs --> fcvtzs.  */
18753    case 389: return NULL;		/* fcvtzs --> NULL.  */
18754    case 412: value = 413; break;	/* fcvtzu --> fcvtzu.  */
18755    case 413: return NULL;		/* fcvtzu --> NULL.  */
18756    case 842: value = 843; break;	/* fmsub --> fmsub.  */
18757    case 843: return NULL;		/* fmsub --> NULL.  */
18758    case 846: value = 847; break;	/* fnmsub --> fnmsub.  */
18759    case 847: return NULL;		/* fnmsub --> NULL.  */
18760    case 592: value = 593; break;	/* scvtf --> scvtf.  */
18761    case 593: return NULL;		/* scvtf --> NULL.  */
18762    case 594: value = 595; break;	/* fcvtzs --> fcvtzs.  */
18763    case 595: return NULL;		/* fcvtzs --> NULL.  */
18764    case 608: value = 609; break;	/* ucvtf --> ucvtf.  */
18765    case 609: return NULL;		/* ucvtf --> NULL.  */
18766    case 610: value = 611; break;	/* fcvtzu --> fcvtzu.  */
18767    case 611: return NULL;		/* fcvtzu --> NULL.  */
18768    default: return NULL;
18769    }
18770
18771  return aarch64_opcode_table + value;
18772}
18773
18774const aarch64_opcode *
18775aarch64_find_alias_opcode (const aarch64_opcode *opcode)
18776{
18777  /* Use the index as the key to locate the alias opcode.  */
18778  int key = opcode - aarch64_opcode_table;
18779  int value;
18780  switch (key)
18781    {
18782    case 2: value = 3; break;	/* sbc --> ngc.  */
18783    case 4: value = 5; break;	/* sbcs --> ngcs.  */
18784    case 7: value = 8; break;	/* adds --> cmn.  */
18785    case 10: value = 11; break;	/* subs --> cmp.  */
18786    case 12: value = 13; break;	/* add --> mov.  */
18787    case 14: value = 15; break;	/* adds --> cmn.  */
18788    case 17: value = 18; break;	/* subs --> cmp.  */
18789    case 20: value = 21; break;	/* adds --> cmn.  */
18790    case 22: value = 23; break;	/* sub --> neg.  */
18791    case 24: value = 26; break;	/* subs --> negs.  */
18792    case 150: value = 151; break;	/* umov --> mov.  */
18793    case 152: value = 153; break;	/* ins --> mov.  */
18794    case 154: value = 155; break;	/* ins --> mov.  */
18795    case 236: value = 237; break;	/* not --> mvn.  */
18796    case 311: value = 312; break;	/* orr --> mov.  */
18797    case 382: value = 383; break;	/* sshll --> sxtl.  */
18798    case 384: value = 385; break;	/* sshll2 --> sxtl2.  */
18799    case 406: value = 407; break;	/* ushll --> uxtl.  */
18800    case 408: value = 409; break;	/* ushll2 --> uxtl2.  */
18801    case 529: value = 530; break;	/* dup --> mov.  */
18802    case 612: value = 617; break;	/* sbfm --> sxtw.  */
18803    case 619: value = 621; break;	/* bfm --> bfc.  */
18804    case 623: value = 627; break;	/* ubfm --> uxth.  */
18805    case 657: value = 659; break;	/* csinc --> cset.  */
18806    case 660: value = 662; break;	/* csinv --> csetm.  */
18807    case 663: value = 664; break;	/* csneg --> cneg.  */
18808    case 682: value = 682; break;	/* rev --> rev.  */
18809    case 707: value = 708; break;	/* lslv --> lsl.  */
18810    case 709: value = 710; break;	/* lsrv --> lsr.  */
18811    case 711: value = 712; break;	/* asrv --> asr.  */
18812    case 713: value = 714; break;	/* rorv --> ror.  */
18813    case 724: value = 725; break;	/* madd --> mul.  */
18814    case 726: value = 727; break;	/* msub --> mneg.  */
18815    case 728: value = 729; break;	/* smaddl --> smull.  */
18816    case 730: value = 731; break;	/* smsubl --> smnegl.  */
18817    case 733: value = 734; break;	/* umaddl --> umull.  */
18818    case 735: value = 736; break;	/* umsubl --> umnegl.  */
18819    case 746: value = 747; break;	/* extr --> ror.  */
18820    case 959: value = 960; break;	/* and --> bic.  */
18821    case 961: value = 962; break;	/* orr --> mov.  */
18822    case 964: value = 965; break;	/* ands --> tst.  */
18823    case 968: value = 970; break;	/* orr --> uxtw.  */
18824    case 971: value = 972; break;	/* orn --> mvn.  */
18825    case 975: value = 976; break;	/* ands --> tst.  */
18826    case 1006: value = 1102; break;	/* ldaddb --> staddb.  */
18827    case 1007: value = 1103; break;	/* ldaddh --> staddh.  */
18828    case 1008: value = 1104; break;	/* ldadd --> stadd.  */
18829    case 1010: value = 1105; break;	/* ldaddlb --> staddlb.  */
18830    case 1013: value = 1106; break;	/* ldaddlh --> staddlh.  */
18831    case 1016: value = 1107; break;	/* ldaddl --> staddl.  */
18832    case 1018: value = 1108; break;	/* ldclrb --> stclrb.  */
18833    case 1019: value = 1109; break;	/* ldclrh --> stclrh.  */
18834    case 1020: value = 1110; break;	/* ldclr --> stclr.  */
18835    case 1022: value = 1111; break;	/* ldclrlb --> stclrlb.  */
18836    case 1025: value = 1112; break;	/* ldclrlh --> stclrlh.  */
18837    case 1028: value = 1113; break;	/* ldclrl --> stclrl.  */
18838    case 1030: value = 1114; break;	/* ldeorb --> steorb.  */
18839    case 1031: value = 1115; break;	/* ldeorh --> steorh.  */
18840    case 1032: value = 1116; break;	/* ldeor --> steor.  */
18841    case 1034: value = 1117; break;	/* ldeorlb --> steorlb.  */
18842    case 1037: value = 1118; break;	/* ldeorlh --> steorlh.  */
18843    case 1040: value = 1119; break;	/* ldeorl --> steorl.  */
18844    case 1042: value = 1120; break;	/* ldsetb --> stsetb.  */
18845    case 1043: value = 1121; break;	/* ldseth --> stseth.  */
18846    case 1044: value = 1122; break;	/* ldset --> stset.  */
18847    case 1046: value = 1123; break;	/* ldsetlb --> stsetlb.  */
18848    case 1049: value = 1124; break;	/* ldsetlh --> stsetlh.  */
18849    case 1052: value = 1125; break;	/* ldsetl --> stsetl.  */
18850    case 1054: value = 1126; break;	/* ldsmaxb --> stsmaxb.  */
18851    case 1055: value = 1127; break;	/* ldsmaxh --> stsmaxh.  */
18852    case 1056: value = 1128; break;	/* ldsmax --> stsmax.  */
18853    case 1058: value = 1129; break;	/* ldsmaxlb --> stsmaxlb.  */
18854    case 1061: value = 1130; break;	/* ldsmaxlh --> stsmaxlh.  */
18855    case 1064: value = 1131; break;	/* ldsmaxl --> stsmaxl.  */
18856    case 1066: value = 1132; break;	/* ldsminb --> stsminb.  */
18857    case 1067: value = 1133; break;	/* ldsminh --> stsminh.  */
18858    case 1068: value = 1134; break;	/* ldsmin --> stsmin.  */
18859    case 1070: value = 1135; break;	/* ldsminlb --> stsminlb.  */
18860    case 1073: value = 1136; break;	/* ldsminlh --> stsminlh.  */
18861    case 1076: value = 1137; break;	/* ldsminl --> stsminl.  */
18862    case 1078: value = 1138; break;	/* ldumaxb --> stumaxb.  */
18863    case 1079: value = 1139; break;	/* ldumaxh --> stumaxh.  */
18864    case 1080: value = 1140; break;	/* ldumax --> stumax.  */
18865    case 1082: value = 1141; break;	/* ldumaxlb --> stumaxlb.  */
18866    case 1085: value = 1142; break;	/* ldumaxlh --> stumaxlh.  */
18867    case 1088: value = 1143; break;	/* ldumaxl --> stumaxl.  */
18868    case 1090: value = 1144; break;	/* lduminb --> stuminb.  */
18869    case 1091: value = 1145; break;	/* lduminh --> stuminh.  */
18870    case 1092: value = 1146; break;	/* ldumin --> stumin.  */
18871    case 1094: value = 1147; break;	/* lduminlb --> stuminlb.  */
18872    case 1097: value = 1148; break;	/* lduminlh --> stuminlh.  */
18873    case 1100: value = 1149; break;	/* lduminl --> stuminl.  */
18874    case 1150: value = 1151; break;	/* movn --> mov.  */
18875    case 1152: value = 1153; break;	/* movz --> mov.  */
18876    case 1158: value = 1191; break;	/* hint --> autibsp.  */
18877    case 1176: value = 1180; break;	/* sys --> tlbi.  */
18878    case 1239: value = 1973; break;	/* and --> bic.  */
18879    case 1241: value = 1222; break;	/* and --> mov.  */
18880    case 1242: value = 1226; break;	/* ands --> movs.  */
18881    case 1277: value = 1974; break;	/* cmpge --> cmple.  */
18882    case 1280: value = 1977; break;	/* cmpgt --> cmplt.  */
18883    case 1282: value = 1975; break;	/* cmphi --> cmplo.  */
18884    case 1285: value = 1976; break;	/* cmphs --> cmpls.  */
18885    case 1307: value = 1219; break;	/* cpy --> mov.  */
18886    case 1308: value = 1221; break;	/* cpy --> mov.  */
18887    case 1309: value = 1984; break;	/* cpy --> fmov.  */
18888    case 1321: value = 1214; break;	/* dup --> mov.  */
18889    case 1322: value = 1216; break;	/* dup --> mov.  */
18890    case 1323: value = 1983; break;	/* dup --> fmov.  */
18891    case 1324: value = 1217; break;	/* dupm --> mov.  */
18892    case 1326: value = 1978; break;	/* eor --> eon.  */
18893    case 1328: value = 1227; break;	/* eor --> not.  */
18894    case 1329: value = 1228; break;	/* eors --> nots.  */
18895    case 1334: value = 1979; break;	/* facge --> facle.  */
18896    case 1335: value = 1980; break;	/* facgt --> faclt.  */
18897    case 1348: value = 1981; break;	/* fcmge --> fcmle.  */
18898    case 1350: value = 1982; break;	/* fcmgt --> fcmlt.  */
18899    case 1356: value = 1211; break;	/* fcpy --> fmov.  */
18900    case 1379: value = 1210; break;	/* fdup --> fmov.  */
18901    case 1694: value = 1212; break;	/* orr --> mov.  */
18902    case 1695: value = 1985; break;	/* orr --> orn.  */
18903    case 1697: value = 1215; break;	/* orr --> mov.  */
18904    case 1698: value = 1225; break;	/* orrs --> movs.  */
18905    case 1760: value = 1220; break;	/* sel --> mov.  */
18906    case 1761: value = 1223; break;	/* sel --> mov.  */
18907    default: return NULL;
18908    }
18909
18910  return aarch64_opcode_table + value;
18911}
18912
18913const aarch64_opcode *
18914aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
18915{
18916  /* Use the index as the key to locate the next opcode.  */
18917  int key = opcode - aarch64_opcode_table;
18918  int value;
18919  switch (key)
18920    {
18921    case 3: value = 2; break;	/* ngc --> sbc.  */
18922    case 5: value = 4; break;	/* ngcs --> sbcs.  */
18923    case 8: value = 7; break;	/* cmn --> adds.  */
18924    case 11: value = 10; break;	/* cmp --> subs.  */
18925    case 13: value = 12; break;	/* mov --> add.  */
18926    case 15: value = 14; break;	/* cmn --> adds.  */
18927    case 18: value = 17; break;	/* cmp --> subs.  */
18928    case 21: value = 20; break;	/* cmn --> adds.  */
18929    case 23: value = 22; break;	/* neg --> sub.  */
18930    case 26: value = 25; break;	/* negs --> cmp.  */
18931    case 25: value = 24; break;	/* cmp --> subs.  */
18932    case 151: value = 150; break;	/* mov --> umov.  */
18933    case 153: value = 152; break;	/* mov --> ins.  */
18934    case 155: value = 154; break;	/* mov --> ins.  */
18935    case 237: value = 236; break;	/* mvn --> not.  */
18936    case 312: value = 311; break;	/* mov --> orr.  */
18937    case 383: value = 382; break;	/* sxtl --> sshll.  */
18938    case 385: value = 384; break;	/* sxtl2 --> sshll2.  */
18939    case 407: value = 406; break;	/* uxtl --> ushll.  */
18940    case 409: value = 408; break;	/* uxtl2 --> ushll2.  */
18941    case 530: value = 529; break;	/* mov --> dup.  */
18942    case 617: value = 616; break;	/* sxtw --> sxth.  */
18943    case 616: value = 615; break;	/* sxth --> sxtb.  */
18944    case 615: value = 618; break;	/* sxtb --> asr.  */
18945    case 618: value = 614; break;	/* asr --> sbfx.  */
18946    case 614: value = 613; break;	/* sbfx --> sbfiz.  */
18947    case 613: value = 612; break;	/* sbfiz --> sbfm.  */
18948    case 621: value = 622; break;	/* bfc --> bfxil.  */
18949    case 622: value = 620; break;	/* bfxil --> bfi.  */
18950    case 620: value = 619; break;	/* bfi --> bfm.  */
18951    case 627: value = 626; break;	/* uxth --> uxtb.  */
18952    case 626: value = 629; break;	/* uxtb --> lsr.  */
18953    case 629: value = 628; break;	/* lsr --> lsl.  */
18954    case 628: value = 625; break;	/* lsl --> ubfx.  */
18955    case 625: value = 624; break;	/* ubfx --> ubfiz.  */
18956    case 624: value = 623; break;	/* ubfiz --> ubfm.  */
18957    case 659: value = 658; break;	/* cset --> cinc.  */
18958    case 658: value = 657; break;	/* cinc --> csinc.  */
18959    case 662: value = 661; break;	/* csetm --> cinv.  */
18960    case 661: value = 660; break;	/* cinv --> csinv.  */
18961    case 664: value = 663; break;	/* cneg --> csneg.  */
18962    case 682: value = 683; break;	/* rev --> rev64.  */
18963    case 708: value = 707; break;	/* lsl --> lslv.  */
18964    case 710: value = 709; break;	/* lsr --> lsrv.  */
18965    case 712: value = 711; break;	/* asr --> asrv.  */
18966    case 714: value = 713; break;	/* ror --> rorv.  */
18967    case 725: value = 724; break;	/* mul --> madd.  */
18968    case 727: value = 726; break;	/* mneg --> msub.  */
18969    case 729: value = 728; break;	/* smull --> smaddl.  */
18970    case 731: value = 730; break;	/* smnegl --> smsubl.  */
18971    case 734: value = 733; break;	/* umull --> umaddl.  */
18972    case 736: value = 735; break;	/* umnegl --> umsubl.  */
18973    case 747: value = 746; break;	/* ror --> extr.  */
18974    case 960: value = 959; break;	/* bic --> and.  */
18975    case 962: value = 961; break;	/* mov --> orr.  */
18976    case 965: value = 964; break;	/* tst --> ands.  */
18977    case 970: value = 969; break;	/* uxtw --> mov.  */
18978    case 969: value = 968; break;	/* mov --> orr.  */
18979    case 972: value = 971; break;	/* mvn --> orn.  */
18980    case 976: value = 975; break;	/* tst --> ands.  */
18981    case 1102: value = 1006; break;	/* staddb --> ldaddb.  */
18982    case 1103: value = 1007; break;	/* staddh --> ldaddh.  */
18983    case 1104: value = 1008; break;	/* stadd --> ldadd.  */
18984    case 1105: value = 1010; break;	/* staddlb --> ldaddlb.  */
18985    case 1106: value = 1013; break;	/* staddlh --> ldaddlh.  */
18986    case 1107: value = 1016; break;	/* staddl --> ldaddl.  */
18987    case 1108: value = 1018; break;	/* stclrb --> ldclrb.  */
18988    case 1109: value = 1019; break;	/* stclrh --> ldclrh.  */
18989    case 1110: value = 1020; break;	/* stclr --> ldclr.  */
18990    case 1111: value = 1022; break;	/* stclrlb --> ldclrlb.  */
18991    case 1112: value = 1025; break;	/* stclrlh --> ldclrlh.  */
18992    case 1113: value = 1028; break;	/* stclrl --> ldclrl.  */
18993    case 1114: value = 1030; break;	/* steorb --> ldeorb.  */
18994    case 1115: value = 1031; break;	/* steorh --> ldeorh.  */
18995    case 1116: value = 1032; break;	/* steor --> ldeor.  */
18996    case 1117: value = 1034; break;	/* steorlb --> ldeorlb.  */
18997    case 1118: value = 1037; break;	/* steorlh --> ldeorlh.  */
18998    case 1119: value = 1040; break;	/* steorl --> ldeorl.  */
18999    case 1120: value = 1042; break;	/* stsetb --> ldsetb.  */
19000    case 1121: value = 1043; break;	/* stseth --> ldseth.  */
19001    case 1122: value = 1044; break;	/* stset --> ldset.  */
19002    case 1123: value = 1046; break;	/* stsetlb --> ldsetlb.  */
19003    case 1124: value = 1049; break;	/* stsetlh --> ldsetlh.  */
19004    case 1125: value = 1052; break;	/* stsetl --> ldsetl.  */
19005    case 1126: value = 1054; break;	/* stsmaxb --> ldsmaxb.  */
19006    case 1127: value = 1055; break;	/* stsmaxh --> ldsmaxh.  */
19007    case 1128: value = 1056; break;	/* stsmax --> ldsmax.  */
19008    case 1129: value = 1058; break;	/* stsmaxlb --> ldsmaxlb.  */
19009    case 1130: value = 1061; break;	/* stsmaxlh --> ldsmaxlh.  */
19010    case 1131: value = 1064; break;	/* stsmaxl --> ldsmaxl.  */
19011    case 1132: value = 1066; break;	/* stsminb --> ldsminb.  */
19012    case 1133: value = 1067; break;	/* stsminh --> ldsminh.  */
19013    case 1134: value = 1068; break;	/* stsmin --> ldsmin.  */
19014    case 1135: value = 1070; break;	/* stsminlb --> ldsminlb.  */
19015    case 1136: value = 1073; break;	/* stsminlh --> ldsminlh.  */
19016    case 1137: value = 1076; break;	/* stsminl --> ldsminl.  */
19017    case 1138: value = 1078; break;	/* stumaxb --> ldumaxb.  */
19018    case 1139: value = 1079; break;	/* stumaxh --> ldumaxh.  */
19019    case 1140: value = 1080; break;	/* stumax --> ldumax.  */
19020    case 1141: value = 1082; break;	/* stumaxlb --> ldumaxlb.  */
19021    case 1142: value = 1085; break;	/* stumaxlh --> ldumaxlh.  */
19022    case 1143: value = 1088; break;	/* stumaxl --> ldumaxl.  */
19023    case 1144: value = 1090; break;	/* stuminb --> lduminb.  */
19024    case 1145: value = 1091; break;	/* stuminh --> lduminh.  */
19025    case 1146: value = 1092; break;	/* stumin --> ldumin.  */
19026    case 1147: value = 1094; break;	/* stuminlb --> lduminlb.  */
19027    case 1148: value = 1097; break;	/* stuminlh --> lduminlh.  */
19028    case 1149: value = 1100; break;	/* stuminl --> lduminl.  */
19029    case 1151: value = 1150; break;	/* mov --> movn.  */
19030    case 1153: value = 1152; break;	/* mov --> movz.  */
19031    case 1191: value = 1190; break;	/* autibsp --> autibz.  */
19032    case 1190: value = 1189; break;	/* autibz --> autiasp.  */
19033    case 1189: value = 1188; break;	/* autiasp --> autiaz.  */
19034    case 1188: value = 1187; break;	/* autiaz --> pacibsp.  */
19035    case 1187: value = 1186; break;	/* pacibsp --> pacibz.  */
19036    case 1186: value = 1185; break;	/* pacibz --> paciasp.  */
19037    case 1185: value = 1184; break;	/* paciasp --> paciaz.  */
19038    case 1184: value = 1171; break;	/* paciaz --> psb.  */
19039    case 1171: value = 1170; break;	/* psb --> esb.  */
19040    case 1170: value = 1169; break;	/* esb --> autib1716.  */
19041    case 1169: value = 1168; break;	/* autib1716 --> autia1716.  */
19042    case 1168: value = 1167; break;	/* autia1716 --> pacib1716.  */
19043    case 1167: value = 1166; break;	/* pacib1716 --> pacia1716.  */
19044    case 1166: value = 1165; break;	/* pacia1716 --> xpaclri.  */
19045    case 1165: value = 1164; break;	/* xpaclri --> sevl.  */
19046    case 1164: value = 1163; break;	/* sevl --> sev.  */
19047    case 1163: value = 1162; break;	/* sev --> wfi.  */
19048    case 1162: value = 1161; break;	/* wfi --> wfe.  */
19049    case 1161: value = 1160; break;	/* wfe --> yield.  */
19050    case 1160: value = 1159; break;	/* yield --> nop.  */
19051    case 1159: value = 1158; break;	/* nop --> hint.  */
19052    case 1180: value = 1179; break;	/* tlbi --> ic.  */
19053    case 1179: value = 1178; break;	/* ic --> dc.  */
19054    case 1178: value = 1177; break;	/* dc --> at.  */
19055    case 1177: value = 1176; break;	/* at --> sys.  */
19056    case 1973: value = 1239; break;	/* bic --> and.  */
19057    case 1222: value = 1241; break;	/* mov --> and.  */
19058    case 1226: value = 1242; break;	/* movs --> ands.  */
19059    case 1974: value = 1277; break;	/* cmple --> cmpge.  */
19060    case 1977: value = 1280; break;	/* cmplt --> cmpgt.  */
19061    case 1975: value = 1282; break;	/* cmplo --> cmphi.  */
19062    case 1976: value = 1285; break;	/* cmpls --> cmphs.  */
19063    case 1219: value = 1307; break;	/* mov --> cpy.  */
19064    case 1221: value = 1308; break;	/* mov --> cpy.  */
19065    case 1984: value = 1224; break;	/* fmov --> mov.  */
19066    case 1224: value = 1309; break;	/* mov --> cpy.  */
19067    case 1214: value = 1321; break;	/* mov --> dup.  */
19068    case 1216: value = 1213; break;	/* mov --> mov.  */
19069    case 1213: value = 1322; break;	/* mov --> dup.  */
19070    case 1983: value = 1218; break;	/* fmov --> mov.  */
19071    case 1218: value = 1323; break;	/* mov --> dup.  */
19072    case 1217: value = 1324; break;	/* mov --> dupm.  */
19073    case 1978: value = 1326; break;	/* eon --> eor.  */
19074    case 1227: value = 1328; break;	/* not --> eor.  */
19075    case 1228: value = 1329; break;	/* nots --> eors.  */
19076    case 1979: value = 1334; break;	/* facle --> facge.  */
19077    case 1980: value = 1335; break;	/* faclt --> facgt.  */
19078    case 1981: value = 1348; break;	/* fcmle --> fcmge.  */
19079    case 1982: value = 1350; break;	/* fcmlt --> fcmgt.  */
19080    case 1211: value = 1356; break;	/* fmov --> fcpy.  */
19081    case 1210: value = 1379; break;	/* fmov --> fdup.  */
19082    case 1212: value = 1694; break;	/* mov --> orr.  */
19083    case 1985: value = 1695; break;	/* orn --> orr.  */
19084    case 1215: value = 1697; break;	/* mov --> orr.  */
19085    case 1225: value = 1698; break;	/* movs --> orrs.  */
19086    case 1220: value = 1760; break;	/* mov --> sel.  */
19087    case 1223: value = 1761; break;	/* mov --> sel.  */
19088    default: return NULL;
19089    }
19090
19091  return aarch64_opcode_table + value;
19092}
19093
19094int
19095aarch64_extract_operand (const aarch64_operand *self,
19096			   aarch64_opnd_info *info,
19097			   aarch64_insn code, const aarch64_inst *inst)
19098{
19099  /* Use the index as the key.  */
19100  int key = self - aarch64_operands;
19101  switch (key)
19102    {
19103    case 1:
19104    case 2:
19105    case 3:
19106    case 4:
19107    case 5:
19108    case 6:
19109    case 7:
19110    case 9:
19111    case 10:
19112    case 11:
19113    case 15:
19114    case 16:
19115    case 17:
19116    case 18:
19117    case 20:
19118    case 21:
19119    case 22:
19120    case 23:
19121    case 24:
19122    case 25:
19123    case 26:
19124    case 27:
19125    case 28:
19126    case 147:
19127    case 148:
19128    case 149:
19129    case 150:
19130    case 151:
19131    case 152:
19132    case 153:
19133    case 154:
19134    case 155:
19135    case 156:
19136    case 169:
19137    case 170:
19138    case 171:
19139    case 172:
19140    case 173:
19141    case 174:
19142    case 175:
19143    case 176:
19144    case 177:
19145    case 181:
19146    case 184:
19147      return aarch64_ext_regno (self, info, code, inst);
19148    case 8:
19149      return aarch64_ext_regrt_sysins (self, info, code, inst);
19150    case 12:
19151      return aarch64_ext_regno_pair (self, info, code, inst);
19152    case 13:
19153      return aarch64_ext_reg_extended (self, info, code, inst);
19154    case 14:
19155      return aarch64_ext_reg_shifted (self, info, code, inst);
19156    case 19:
19157      return aarch64_ext_ft (self, info, code, inst);
19158    case 29:
19159    case 30:
19160    case 31:
19161      return aarch64_ext_reglane (self, info, code, inst);
19162    case 32:
19163      return aarch64_ext_reglist (self, info, code, inst);
19164    case 33:
19165      return aarch64_ext_ldst_reglist (self, info, code, inst);
19166    case 34:
19167      return aarch64_ext_ldst_reglist_r (self, info, code, inst);
19168    case 35:
19169      return aarch64_ext_ldst_elemlist (self, info, code, inst);
19170    case 36:
19171    case 37:
19172    case 38:
19173    case 48:
19174    case 49:
19175    case 50:
19176    case 51:
19177    case 52:
19178    case 53:
19179    case 54:
19180    case 55:
19181    case 56:
19182    case 57:
19183    case 58:
19184    case 59:
19185    case 60:
19186    case 71:
19187    case 72:
19188    case 73:
19189    case 74:
19190    case 75:
19191    case 144:
19192    case 146:
19193    case 161:
19194    case 162:
19195    case 163:
19196    case 164:
19197    case 165:
19198    case 166:
19199    case 167:
19200    case 168:
19201      return aarch64_ext_imm (self, info, code, inst);
19202    case 39:
19203    case 40:
19204      return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
19205    case 41:
19206    case 42:
19207    case 43:
19208      return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
19209    case 44:
19210      return aarch64_ext_shll_imm (self, info, code, inst);
19211    case 47:
19212    case 135:
19213      return aarch64_ext_fpimm (self, info, code, inst);
19214    case 61:
19215    case 142:
19216      return aarch64_ext_limm (self, info, code, inst);
19217    case 62:
19218      return aarch64_ext_aimm (self, info, code, inst);
19219    case 63:
19220      return aarch64_ext_imm_half (self, info, code, inst);
19221    case 64:
19222      return aarch64_ext_fbits (self, info, code, inst);
19223    case 66:
19224    case 67:
19225    case 140:
19226      return aarch64_ext_imm_rotate2 (self, info, code, inst);
19227    case 68:
19228    case 139:
19229      return aarch64_ext_imm_rotate1 (self, info, code, inst);
19230    case 69:
19231    case 70:
19232      return aarch64_ext_cond (self, info, code, inst);
19233    case 76:
19234    case 83:
19235      return aarch64_ext_addr_simple (self, info, code, inst);
19236    case 77:
19237      return aarch64_ext_addr_regoff (self, info, code, inst);
19238    case 78:
19239    case 79:
19240    case 80:
19241      return aarch64_ext_addr_simm (self, info, code, inst);
19242    case 81:
19243      return aarch64_ext_addr_simm10 (self, info, code, inst);
19244    case 82:
19245      return aarch64_ext_addr_uimm12 (self, info, code, inst);
19246    case 84:
19247      return aarch64_ext_simd_addr_post (self, info, code, inst);
19248    case 85:
19249      return aarch64_ext_sysreg (self, info, code, inst);
19250    case 86:
19251      return aarch64_ext_pstatefield (self, info, code, inst);
19252    case 87:
19253    case 88:
19254    case 89:
19255    case 90:
19256      return aarch64_ext_sysins_op (self, info, code, inst);
19257    case 91:
19258    case 92:
19259      return aarch64_ext_barrier (self, info, code, inst);
19260    case 93:
19261      return aarch64_ext_prfop (self, info, code, inst);
19262    case 94:
19263      return aarch64_ext_hint (self, info, code, inst);
19264    case 95:
19265      return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst);
19266    case 96:
19267    case 97:
19268    case 98:
19269    case 99:
19270      return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst);
19271    case 100:
19272      return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst);
19273    case 101:
19274      return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst);
19275    case 102:
19276    case 103:
19277    case 104:
19278    case 105:
19279      return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst);
19280    case 106:
19281    case 107:
19282    case 108:
19283    case 109:
19284    case 110:
19285    case 111:
19286    case 112:
19287    case 113:
19288    case 114:
19289    case 115:
19290    case 116:
19291    case 117:
19292      return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst);
19293    case 118:
19294    case 119:
19295    case 120:
19296    case 121:
19297    case 122:
19298    case 123:
19299    case 124:
19300    case 125:
19301      return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst);
19302    case 126:
19303    case 127:
19304    case 128:
19305    case 129:
19306      return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst);
19307    case 130:
19308      return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst);
19309    case 131:
19310      return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst);
19311    case 132:
19312      return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst);
19313    case 133:
19314      return aarch64_ext_sve_aimm (self, info, code, inst);
19315    case 134:
19316      return aarch64_ext_sve_asimm (self, info, code, inst);
19317    case 136:
19318      return aarch64_ext_sve_float_half_one (self, info, code, inst);
19319    case 137:
19320      return aarch64_ext_sve_float_half_two (self, info, code, inst);
19321    case 138:
19322      return aarch64_ext_sve_float_zero_one (self, info, code, inst);
19323    case 141:
19324      return aarch64_ext_inv_limm (self, info, code, inst);
19325    case 143:
19326      return aarch64_ext_sve_limm_mov (self, info, code, inst);
19327    case 145:
19328      return aarch64_ext_sve_scale (self, info, code, inst);
19329    case 157:
19330    case 158:
19331      return aarch64_ext_sve_shlimm (self, info, code, inst);
19332    case 159:
19333    case 160:
19334      return aarch64_ext_sve_shrimm (self, info, code, inst);
19335    case 178:
19336    case 179:
19337    case 180:
19338      return aarch64_ext_sve_quad_index (self, info, code, inst);
19339    case 182:
19340      return aarch64_ext_sve_index (self, info, code, inst);
19341    case 183:
19342    case 185:
19343      return aarch64_ext_sve_reglist (self, info, code, inst);
19344    default: assert (0); abort ();
19345    }
19346}
19347