1/* This file is automatically generated by aarch64-gen.  Do not edit!  */
2/* Copyright (C) 2012-2022 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 >> 28) & 0x1) == 0)
38                    {
39                      if (((word >> 21) & 0x1) == 0)
40                        {
41                          if (((word >> 29) & 0x1) == 0)
42                            {
43                              if (((word >> 30) & 0x1) == 0)
44                                {
45                                  if (((word >> 22) & 0x1) == 0)
46                                    {
47                                      if (((word >> 23) & 0x1) == 0)
48                                        {
49                                          /* 33222222222211111111110000000000
50                                             10987654321098765432109876543210
51                                             x0000000000xxxxxxxxxxxxxxxxxxxxx
52                                             udf.  */
53                                          return 754;
54                                        }
55                                      else
56                                        {
57                                          if (((word >> 4) & 0x1) == 0)
58                                            {
59                                              /* 33222222222211111111110000000000
60                                                 10987654321098765432109876543210
61                                                 x0000000100xxxxxxxxxxxxxxxx0xxxx
62                                                 fmopa.  */
63                                              return 2360;
64                                            }
65                                          else
66                                            {
67                                              /* 33222222222211111111110000000000
68                                                 10987654321098765432109876543210
69                                                 x0000000100xxxxxxxxxxxxxxxx1xxxx
70                                                 fmops.  */
71                                              return 2363;
72                                            }
73                                        }
74                                    }
75                                  else
76                                    {
77                                      if (((word >> 4) & 0x1) == 0)
78                                        {
79                                          /* 33222222222211111111110000000000
80                                             10987654321098765432109876543210
81                                             x0000000x10xxxxxxxxxxxxxxxx0xxxx
82                                             fmopa.  */
83                                          return 2361;
84                                        }
85                                      else
86                                        {
87                                          /* 33222222222211111111110000000000
88                                             10987654321098765432109876543210
89                                             x0000000x10xxxxxxxxxxxxxxxx1xxxx
90                                             fmops.  */
91                                          return 2364;
92                                        }
93                                    }
94                                }
95                              else
96                                {
97                                  if (((word >> 17) & 0x1) == 0)
98                                    {
99                                      if (((word >> 19) & 0x1) == 0)
100                                        {
101                                          if (((word >> 20) & 0x1) == 0)
102                                            {
103                                              /* 33222222222211111111110000000000
104                                                 10987654321098765432109876543210
105                                                 x1000000xx000x0xxxxxxxxxxxxxxxxx
106                                                 mov.  */
107                                              return 2384;
108                                            }
109                                          else
110                                            {
111                                              if (((word >> 16) & 0x1) == 0)
112                                                {
113                                                  if (((word >> 22) & 0x1) == 0)
114                                                    {
115                                                      /* 33222222222211111111110000000000
116                                                         10987654321098765432109876543210
117                                                         x1000000x0010x00xxxxxxxxxxxxxxxx
118                                                         addha.  */
119                                                      return 2352;
120                                                    }
121                                                  else
122                                                    {
123                                                      /* 33222222222211111111110000000000
124                                                         10987654321098765432109876543210
125                                                         x1000000x1010x00xxxxxxxxxxxxxxxx
126                                                         addha.  */
127                                                      return 2353;
128                                                    }
129                                                }
130                                              else
131                                                {
132                                                  if (((word >> 22) & 0x1) == 0)
133                                                    {
134                                                      /* 33222222222211111111110000000000
135                                                         10987654321098765432109876543210
136                                                         x1000000x0010x01xxxxxxxxxxxxxxxx
137                                                         addva.  */
138                                                      return 2356;
139                                                    }
140                                                  else
141                                                    {
142                                                      /* 33222222222211111111110000000000
143                                                         10987654321098765432109876543210
144                                                         x1000000x1010x01xxxxxxxxxxxxxxxx
145                                                         addva.  */
146                                                      return 2357;
147                                                    }
148                                                }
149                                            }
150                                        }
151                                      else
152                                        {
153                                          /* 33222222222211111111110000000000
154                                             10987654321098765432109876543210
155                                             x1000000xx0x1x0xxxxxxxxxxxxxxxxx
156                                             zero.  */
157                                          return 2387;
158                                        }
159                                    }
160                                  else
161                                    {
162                                      /* 33222222222211111111110000000000
163                                         10987654321098765432109876543210
164                                         x1000000xx0xxx1xxxxxxxxxxxxxxxxx
165                                         mov.  */
166                                      return 2383;
167                                    }
168                                }
169                            }
170                          else
171                            {
172                              if (((word >> 4) & 0x1) == 0)
173                                {
174                                  if (((word >> 22) & 0x1) == 0)
175                                    {
176                                      if (((word >> 23) & 0x1) == 0)
177                                        {
178                                          /* 33222222222211111111110000000000
179                                             10987654321098765432109876543210
180                                             xx100000000xxxxxxxxxxxxxxxx0xxxx
181                                             ld1b.  */
182                                          return 2388;
183                                        }
184                                      else
185                                        {
186                                          if (((word >> 30) & 0x1) == 0)
187                                            {
188                                              /* 33222222222211111111110000000000
189                                                 10987654321098765432109876543210
190                                                 x0100000100xxxxxxxxxxxxxxxx0xxxx
191                                                 smopa.  */
192                                              return 2367;
193                                            }
194                                          else
195                                            {
196                                              /* 33222222222211111111110000000000
197                                                 10987654321098765432109876543210
198                                                 x1100000100xxxxxxxxxxxxxxxx0xxxx
199                                                 ld1w.  */
200                                              return 2390;
201                                            }
202                                        }
203                                    }
204                                  else
205                                    {
206                                      if (((word >> 23) & 0x1) == 0)
207                                        {
208                                          /* 33222222222211111111110000000000
209                                             10987654321098765432109876543210
210                                             xx100000010xxxxxxxxxxxxxxxx0xxxx
211                                             ld1h.  */
212                                          return 2389;
213                                        }
214                                      else
215                                        {
216                                          if (((word >> 30) & 0x1) == 0)
217                                            {
218                                              /* 33222222222211111111110000000000
219                                                 10987654321098765432109876543210
220                                                 x0100000110xxxxxxxxxxxxxxxx0xxxx
221                                                 smopa.  */
222                                              return 2368;
223                                            }
224                                          else
225                                            {
226                                              /* 33222222222211111111110000000000
227                                                 10987654321098765432109876543210
228                                                 x1100000110xxxxxxxxxxxxxxxx0xxxx
229                                                 ld1d.  */
230                                              return 2391;
231                                            }
232                                        }
233                                    }
234                                }
235                              else
236                                {
237                                  if (((word >> 22) & 0x1) == 0)
238                                    {
239                                      /* 33222222222211111111110000000000
240                                         10987654321098765432109876543210
241                                         xx100000x00xxxxxxxxxxxxxxxx1xxxx
242                                         smops.  */
243                                      return 2369;
244                                    }
245                                  else
246                                    {
247                                      /* 33222222222211111111110000000000
248                                         10987654321098765432109876543210
249                                         xx100000x10xxxxxxxxxxxxxxxx1xxxx
250                                         smops.  */
251                                      return 2370;
252                                    }
253                                }
254                            }
255                        }
256                      else
257                        {
258                          if (((word >> 4) & 0x1) == 0)
259                            {
260                              if (((word >> 22) & 0x1) == 0)
261                                {
262                                  if (((word >> 23) & 0x1) == 0)
263                                    {
264                                      /* 33222222222211111111110000000000
265                                         10987654321098765432109876543210
266                                         xxx00000001xxxxxxxxxxxxxxxx0xxxx
267                                         st1b.  */
268                                      return 2398;
269                                    }
270                                  else
271                                    {
272                                      if (((word >> 30) & 0x1) == 0)
273                                        {
274                                          /* 33222222222211111111110000000000
275                                             10987654321098765432109876543210
276                                             x0x00000101xxxxxxxxxxxxxxxx0xxxx
277                                             sumopa.  */
278                                          return 2371;
279                                        }
280                                      else
281                                        {
282                                          /* 33222222222211111111110000000000
283                                             10987654321098765432109876543210
284                                             x1x00000101xxxxxxxxxxxxxxxx0xxxx
285                                             st1w.  */
286                                          return 2400;
287                                        }
288                                    }
289                                }
290                              else
291                                {
292                                  if (((word >> 23) & 0x1) == 0)
293                                    {
294                                      /* 33222222222211111111110000000000
295                                         10987654321098765432109876543210
296                                         xxx00000011xxxxxxxxxxxxxxxx0xxxx
297                                         st1h.  */
298                                      return 2399;
299                                    }
300                                  else
301                                    {
302                                      if (((word >> 30) & 0x1) == 0)
303                                        {
304                                          /* 33222222222211111111110000000000
305                                             10987654321098765432109876543210
306                                             x0x00000111xxxxxxxxxxxxxxxx0xxxx
307                                             sumopa.  */
308                                          return 2372;
309                                        }
310                                      else
311                                        {
312                                          /* 33222222222211111111110000000000
313                                             10987654321098765432109876543210
314                                             x1x00000111xxxxxxxxxxxxxxxx0xxxx
315                                             st1d.  */
316                                          return 2401;
317                                        }
318                                    }
319                                }
320                            }
321                          else
322                            {
323                              if (((word >> 22) & 0x1) == 0)
324                                {
325                                  /* 33222222222211111111110000000000
326                                     10987654321098765432109876543210
327                                     xxx00000x01xxxxxxxxxxxxxxxx1xxxx
328                                     sumops.  */
329                                  return 2373;
330                                }
331                              else
332                                {
333                                  /* 33222222222211111111110000000000
334                                     10987654321098765432109876543210
335                                     xxx00000x11xxxxxxxxxxxxxxxx1xxxx
336                                     sumops.  */
337                                  return 2374;
338                                }
339                            }
340                        }
341                    }
342                  else
343                    {
344                      if (((word >> 31) & 0x1) == 0)
345                        {
346                          /* 33222222222211111111110000000000
347                             10987654321098765432109876543210
348                             0xx10000xxxxxxxxxxxxxxxxxxxxxxxx
349                             adr.  */
350                          return 1191;
351                        }
352                      else
353                        {
354                          /* 33222222222211111111110000000000
355                             10987654321098765432109876543210
356                             1xx10000xxxxxxxxxxxxxxxxxxxxxxxx
357                             adrp.  */
358                          return 1192;
359                        }
360                    }
361                }
362              else
363                {
364                  if (((word >> 28) & 0x1) == 0)
365                    {
366                      if (((word >> 4) & 0x1) == 0)
367                        {
368                          if (((word >> 21) & 0x1) == 0)
369                            {
370                              if (((word >> 22) & 0x1) == 0)
371                                {
372                                  if (((word >> 23) & 0x1) == 0)
373                                    {
374                                      /* 33222222222211111111110000000000
375                                         10987654321098765432109876543210
376                                         xxx00001000xxxxxxxxxxxxxxxx0xxxx
377                                         ldr.  */
378                                      return 2408;
379                                    }
380                                  else
381                                    {
382                                      if (((word >> 29) & 0x1) == 0)
383                                        {
384                                          /* 33222222222211111111110000000000
385                                             10987654321098765432109876543210
386                                             xx000001100xxxxxxxxxxxxxxxx0xxxx
387                                             bfmopa.  */
388                                          return 2358;
389                                        }
390                                      else
391                                        {
392                                          /* 33222222222211111111110000000000
393                                             10987654321098765432109876543210
394                                             xx100001100xxxxxxxxxxxxxxxx0xxxx
395                                             usmopa.  */
396                                          return 2379;
397                                        }
398                                    }
399                                }
400                              else
401                                {
402                                  if (((word >> 30) & 0x1) == 0)
403                                    {
404                                      /* 33222222222211111111110000000000
405                                         10987654321098765432109876543210
406                                         x0x00001x10xxxxxxxxxxxxxxxx0xxxx
407                                         usmopa.  */
408                                      return 2380;
409                                    }
410                                  else
411                                    {
412                                      /* 33222222222211111111110000000000
413                                         10987654321098765432109876543210
414                                         x1x00001x10xxxxxxxxxxxxxxxx0xxxx
415                                         ld1q.  */
416                                      return 2392;
417                                    }
418                                }
419                            }
420                          else
421                            {
422                              if (((word >> 22) & 0x1) == 0)
423                                {
424                                  if (((word >> 23) & 0x1) == 0)
425                                    {
426                                      /* 33222222222211111111110000000000
427                                         10987654321098765432109876543210
428                                         xxx00001001xxxxxxxxxxxxxxxx0xxxx
429                                         str.  */
430                                      return 2409;
431                                    }
432                                  else
433                                    {
434                                      if (((word >> 29) & 0x1) == 0)
435                                        {
436                                          /* 33222222222211111111110000000000
437                                             10987654321098765432109876543210
438                                             xx000001101xxxxxxxxxxxxxxxx0xxxx
439                                             fmopa.  */
440                                          return 2362;
441                                        }
442                                      else
443                                        {
444                                          /* 33222222222211111111110000000000
445                                             10987654321098765432109876543210
446                                             xx100001101xxxxxxxxxxxxxxxx0xxxx
447                                             umopa.  */
448                                          return 2375;
449                                        }
450                                    }
451                                }
452                              else
453                                {
454                                  if (((word >> 30) & 0x1) == 0)
455                                    {
456                                      /* 33222222222211111111110000000000
457                                         10987654321098765432109876543210
458                                         x0x00001x11xxxxxxxxxxxxxxxx0xxxx
459                                         umopa.  */
460                                      return 2376;
461                                    }
462                                  else
463                                    {
464                                      /* 33222222222211111111110000000000
465                                         10987654321098765432109876543210
466                                         x1x00001x11xxxxxxxxxxxxxxxx0xxxx
467                                         st1q.  */
468                                      return 2402;
469                                    }
470                                }
471                            }
472                        }
473                      else
474                        {
475                          if (((word >> 21) & 0x1) == 0)
476                            {
477                              if (((word >> 22) & 0x1) == 0)
478                                {
479                                  if (((word >> 29) & 0x1) == 0)
480                                    {
481                                      /* 33222222222211111111110000000000
482                                         10987654321098765432109876543210
483                                         xx000001x00xxxxxxxxxxxxxxxx1xxxx
484                                         bfmops.  */
485                                      return 2359;
486                                    }
487                                  else
488                                    {
489                                      /* 33222222222211111111110000000000
490                                         10987654321098765432109876543210
491                                         xx100001x00xxxxxxxxxxxxxxxx1xxxx
492                                         usmops.  */
493                                      return 2381;
494                                    }
495                                }
496                              else
497                                {
498                                  /* 33222222222211111111110000000000
499                                     10987654321098765432109876543210
500                                     xxx00001x10xxxxxxxxxxxxxxxx1xxxx
501                                     usmops.  */
502                                  return 2382;
503                                }
504                            }
505                          else
506                            {
507                              if (((word >> 22) & 0x1) == 0)
508                                {
509                                  if (((word >> 29) & 0x1) == 0)
510                                    {
511                                      /* 33222222222211111111110000000000
512                                         10987654321098765432109876543210
513                                         xx000001x01xxxxxxxxxxxxxxxx1xxxx
514                                         fmops.  */
515                                      return 2365;
516                                    }
517                                  else
518                                    {
519                                      /* 33222222222211111111110000000000
520                                         10987654321098765432109876543210
521                                         xx100001x01xxxxxxxxxxxxxxxx1xxxx
522                                         umops.  */
523                                      return 2377;
524                                    }
525                                }
526                              else
527                                {
528                                  /* 33222222222211111111110000000000
529                                     10987654321098765432109876543210
530                                     xxx00001x11xxxxxxxxxxxxxxxx1xxxx
531                                     umops.  */
532                                  return 2378;
533                                }
534                            }
535                        }
536                    }
537                  else
538                    {
539                      if (((word >> 29) & 0x1) == 0)
540                        {
541                          if (((word >> 30) & 0x1) == 0)
542                            {
543                              /* 33222222222211111111110000000000
544                                 10987654321098765432109876543210
545                                 x0010001xxxxxxxxxxxxxxxxxxxxxxxx
546                                 add.  */
547                              return 12;
548                            }
549                          else
550                            {
551                              /* 33222222222211111111110000000000
552                                 10987654321098765432109876543210
553                                 x1010001xxxxxxxxxxxxxxxxxxxxxxxx
554                                 sub.  */
555                              return 16;
556                            }
557                        }
558                      else
559                        {
560                          if (((word >> 30) & 0x1) == 0)
561                            {
562                              /* 33222222222211111111110000000000
563                                 10987654321098765432109876543210
564                                 x0110001xxxxxxxxxxxxxxxxxxxxxxxx
565                                 adds.  */
566                              return 14;
567                            }
568                          else
569                            {
570                              /* 33222222222211111111110000000000
571                                 10987654321098765432109876543210
572                                 x1110001xxxxxxxxxxxxxxxxxxxxxxxx
573                                 subs.  */
574                              return 17;
575                            }
576                        }
577                    }
578                }
579            }
580          else
581            {
582              if (((word >> 28) & 0x1) == 0)
583                {
584                  if (((word >> 22) & 0x1) == 0)
585                    {
586                      if (((word >> 23) & 0x1) == 0)
587                        {
588                          if (((word >> 29) & 0x1) == 0)
589                            {
590                              if (((word >> 15) & 0x1) == 0)
591                                {
592                                  if (((word >> 21) & 0x1) == 0)
593                                    {
594                                      if (((word >> 31) & 0x1) == 0)
595                                        {
596                                          if (((word >> 30) & 0x1) == 0)
597                                            {
598                                              /* 33222222222211111111110000000000
599                                                 10987654321098765432109876543210
600                                                 0000100x000xxxxx0xxxxxxxxxxxxxxx
601                                                 stxrb.  */
602                                              return 937;
603                                            }
604                                          else
605                                            {
606                                              /* 33222222222211111111110000000000
607                                                 10987654321098765432109876543210
608                                                 0100100x000xxxxx0xxxxxxxxxxxxxxx
609                                                 stxrh.  */
610                                              return 943;
611                                            }
612                                        }
613                                      else
614                                        {
615                                          /* 33222222222211111111110000000000
616                                             10987654321098765432109876543210
617                                             1x00100x000xxxxx0xxxxxxxxxxxxxxx
618                                             stxr.  */
619                                          return 949;
620                                        }
621                                    }
622                                  else
623                                    {
624                                      if (((word >> 31) & 0x1) == 0)
625                                        {
626                                          /* 33222222222211111111110000000000
627                                             10987654321098765432109876543210
628                                             0x00100x001xxxxx0xxxxxxxxxxxxxxx
629                                             casp.  */
630                                          return 1026;
631                                        }
632                                      else
633                                        {
634                                          /* 33222222222211111111110000000000
635                                             10987654321098765432109876543210
636                                             1x00100x001xxxxx0xxxxxxxxxxxxxxx
637                                             stxp.  */
638                                          return 951;
639                                        }
640                                    }
641                                }
642                              else
643                                {
644                                  if (((word >> 21) & 0x1) == 0)
645                                    {
646                                      if (((word >> 31) & 0x1) == 0)
647                                        {
648                                          if (((word >> 30) & 0x1) == 0)
649                                            {
650                                              /* 33222222222211111111110000000000
651                                                 10987654321098765432109876543210
652                                                 0000100x000xxxxx1xxxxxxxxxxxxxxx
653                                                 stlxrb.  */
654                                              return 938;
655                                            }
656                                          else
657                                            {
658                                              /* 33222222222211111111110000000000
659                                                 10987654321098765432109876543210
660                                                 0100100x000xxxxx1xxxxxxxxxxxxxxx
661                                                 stlxrh.  */
662                                              return 944;
663                                            }
664                                        }
665                                      else
666                                        {
667                                          /* 33222222222211111111110000000000
668                                             10987654321098765432109876543210
669                                             1x00100x000xxxxx1xxxxxxxxxxxxxxx
670                                             stlxr.  */
671                                          return 950;
672                                        }
673                                    }
674                                  else
675                                    {
676                                      if (((word >> 31) & 0x1) == 0)
677                                        {
678                                          /* 33222222222211111111110000000000
679                                             10987654321098765432109876543210
680                                             0x00100x001xxxxx1xxxxxxxxxxxxxxx
681                                             caspl.  */
682                                          return 1028;
683                                        }
684                                      else
685                                        {
686                                          /* 33222222222211111111110000000000
687                                             10987654321098765432109876543210
688                                             1x00100x001xxxxx1xxxxxxxxxxxxxxx
689                                             stlxp.  */
690                                          return 952;
691                                        }
692                                    }
693                                }
694                            }
695                          else
696                            {
697                              if (((word >> 30) & 0x1) == 0)
698                                {
699                                  /* 33222222222211111111110000000000
700                                     10987654321098765432109876543210
701                                     x010100x00xxxxxxxxxxxxxxxxxxxxxx
702                                     stnp.  */
703                                  return 971;
704                                }
705                              else
706                                {
707                                  /* 33222222222211111111110000000000
708                                     10987654321098765432109876543210
709                                     x110100x00xxxxxxxxxxxxxxxxxxxxxx
710                                     stgp.  */
711                                  return 980;
712                                }
713                            }
714                        }
715                      else
716                        {
717                          if (((word >> 29) & 0x1) == 0)
718                            {
719                              if (((word >> 15) & 0x1) == 0)
720                                {
721                                  if (((word >> 21) & 0x1) == 0)
722                                    {
723                                      if (((word >> 31) & 0x1) == 0)
724                                        {
725                                          /* 33222222222211111111110000000000
726                                             10987654321098765432109876543210
727                                             0x00100x100xxxxx0xxxxxxxxxxxxxxx
728                                             stllrb.  */
729                                          return 969;
730                                        }
731                                      else
732                                        {
733                                          /* 33222222222211111111110000000000
734                                             10987654321098765432109876543210
735                                             1x00100x100xxxxx0xxxxxxxxxxxxxxx
736                                             stllr.  */
737                                          return 968;
738                                        }
739                                    }
740                                  else
741                                    {
742                                      if (((word >> 31) & 0x1) == 0)
743                                        {
744                                          if (((word >> 30) & 0x1) == 0)
745                                            {
746                                              /* 33222222222211111111110000000000
747                                                 10987654321098765432109876543210
748                                                 0000100x101xxxxx0xxxxxxxxxxxxxxx
749                                                 casb.  */
750                                              return 1014;
751                                            }
752                                          else
753                                            {
754                                              /* 33222222222211111111110000000000
755                                                 10987654321098765432109876543210
756                                                 0100100x101xxxxx0xxxxxxxxxxxxxxx
757                                                 cash.  */
758                                              return 1015;
759                                            }
760                                        }
761                                      else
762                                        {
763                                          /* 33222222222211111111110000000000
764                                             10987654321098765432109876543210
765                                             1x00100x101xxxxx0xxxxxxxxxxxxxxx
766                                             cas.  */
767                                          return 1016;
768                                        }
769                                    }
770                                }
771                              else
772                                {
773                                  if (((word >> 21) & 0x1) == 0)
774                                    {
775                                      if (((word >> 31) & 0x1) == 0)
776                                        {
777                                          if (((word >> 30) & 0x1) == 0)
778                                            {
779                                              /* 33222222222211111111110000000000
780                                                 10987654321098765432109876543210
781                                                 0000100x100xxxxx1xxxxxxxxxxxxxxx
782                                                 stlrb.  */
783                                              return 941;
784                                            }
785                                          else
786                                            {
787                                              /* 33222222222211111111110000000000
788                                                 10987654321098765432109876543210
789                                                 0100100x100xxxxx1xxxxxxxxxxxxxxx
790                                                 stlrh.  */
791                                              return 947;
792                                            }
793                                        }
794                                      else
795                                        {
796                                          /* 33222222222211111111110000000000
797                                             10987654321098765432109876543210
798                                             1x00100x100xxxxx1xxxxxxxxxxxxxxx
799                                             stlr.  */
800                                          return 957;
801                                        }
802                                    }
803                                  else
804                                    {
805                                      if (((word >> 31) & 0x1) == 0)
806                                        {
807                                          if (((word >> 30) & 0x1) == 0)
808                                            {
809                                              /* 33222222222211111111110000000000
810                                                 10987654321098765432109876543210
811                                                 0000100x101xxxxx1xxxxxxxxxxxxxxx
812                                                 caslb.  */
813                                              return 1018;
814                                            }
815                                          else
816                                            {
817                                              /* 33222222222211111111110000000000
818                                                 10987654321098765432109876543210
819                                                 0100100x101xxxxx1xxxxxxxxxxxxxxx
820                                                 caslh.  */
821                                              return 1021;
822                                            }
823                                        }
824                                      else
825                                        {
826                                          /* 33222222222211111111110000000000
827                                             10987654321098765432109876543210
828                                             1x00100x101xxxxx1xxxxxxxxxxxxxxx
829                                             casl.  */
830                                          return 1024;
831                                        }
832                                    }
833                                }
834                            }
835                          else
836                            {
837                              if (((word >> 30) & 0x1) == 0)
838                                {
839                                  /* 33222222222211111111110000000000
840                                     10987654321098765432109876543210
841                                     x010100x10xxxxxxxxxxxxxxxxxxxxxx
842                                     stp.  */
843                                  return 981;
844                                }
845                              else
846                                {
847                                  /* 33222222222211111111110000000000
848                                     10987654321098765432109876543210
849                                     x110100x10xxxxxxxxxxxxxxxxxxxxxx
850                                     stgp.  */
851                                  return 986;
852                                }
853                            }
854                        }
855                    }
856                  else
857                    {
858                      if (((word >> 23) & 0x1) == 0)
859                        {
860                          if (((word >> 29) & 0x1) == 0)
861                            {
862                              if (((word >> 15) & 0x1) == 0)
863                                {
864                                  if (((word >> 21) & 0x1) == 0)
865                                    {
866                                      if (((word >> 31) & 0x1) == 0)
867                                        {
868                                          if (((word >> 30) & 0x1) == 0)
869                                            {
870                                              /* 33222222222211111111110000000000
871                                                 10987654321098765432109876543210
872                                                 0000100x010xxxxx0xxxxxxxxxxxxxxx
873                                                 ldxrb.  */
874                                              return 939;
875                                            }
876                                          else
877                                            {
878                                              /* 33222222222211111111110000000000
879                                                 10987654321098765432109876543210
880                                                 0100100x010xxxxx0xxxxxxxxxxxxxxx
881                                                 ldxrh.  */
882                                              return 945;
883                                            }
884                                        }
885                                      else
886                                        {
887                                          /* 33222222222211111111110000000000
888                                             10987654321098765432109876543210
889                                             1x00100x010xxxxx0xxxxxxxxxxxxxxx
890                                             ldxr.  */
891                                          return 953;
892                                        }
893                                    }
894                                  else
895                                    {
896                                      if (((word >> 31) & 0x1) == 0)
897                                        {
898                                          /* 33222222222211111111110000000000
899                                             10987654321098765432109876543210
900                                             0x00100x011xxxxx0xxxxxxxxxxxxxxx
901                                             caspa.  */
902                                          return 1027;
903                                        }
904                                      else
905                                        {
906                                          /* 33222222222211111111110000000000
907                                             10987654321098765432109876543210
908                                             1x00100x011xxxxx0xxxxxxxxxxxxxxx
909                                             ldxp.  */
910                                          return 955;
911                                        }
912                                    }
913                                }
914                              else
915                                {
916                                  if (((word >> 21) & 0x1) == 0)
917                                    {
918                                      if (((word >> 31) & 0x1) == 0)
919                                        {
920                                          if (((word >> 30) & 0x1) == 0)
921                                            {
922                                              /* 33222222222211111111110000000000
923                                                 10987654321098765432109876543210
924                                                 0000100x010xxxxx1xxxxxxxxxxxxxxx
925                                                 ldaxrb.  */
926                                              return 940;
927                                            }
928                                          else
929                                            {
930                                              /* 33222222222211111111110000000000
931                                                 10987654321098765432109876543210
932                                                 0100100x010xxxxx1xxxxxxxxxxxxxxx
933                                                 ldaxrh.  */
934                                              return 946;
935                                            }
936                                        }
937                                      else
938                                        {
939                                          /* 33222222222211111111110000000000
940                                             10987654321098765432109876543210
941                                             1x00100x010xxxxx1xxxxxxxxxxxxxxx
942                                             ldaxr.  */
943                                          return 954;
944                                        }
945                                    }
946                                  else
947                                    {
948                                      if (((word >> 31) & 0x1) == 0)
949                                        {
950                                          /* 33222222222211111111110000000000
951                                             10987654321098765432109876543210
952                                             0x00100x011xxxxx1xxxxxxxxxxxxxxx
953                                             caspal.  */
954                                          return 1029;
955                                        }
956                                      else
957                                        {
958                                          /* 33222222222211111111110000000000
959                                             10987654321098765432109876543210
960                                             1x00100x011xxxxx1xxxxxxxxxxxxxxx
961                                             ldaxp.  */
962                                          return 956;
963                                        }
964                                    }
965                                }
966                            }
967                          else
968                            {
969                              if (((word >> 30) & 0x1) == 0)
970                                {
971                                  /* 33222222222211111111110000000000
972                                     10987654321098765432109876543210
973                                     x010100x01xxxxxxxxxxxxxxxxxxxxxx
974                                     ldnp.  */
975                                  return 972;
976                                }
977                              else
978                                {
979                                  /* 33222222222211111111110000000000
980                                     10987654321098765432109876543210
981                                     x110100x01xxxxxxxxxxxxxxxxxxxxxx
982                                     ldpsw.  */
983                                  return 979;
984                                }
985                            }
986                        }
987                      else
988                        {
989                          if (((word >> 29) & 0x1) == 0)
990                            {
991                              if (((word >> 15) & 0x1) == 0)
992                                {
993                                  if (((word >> 21) & 0x1) == 0)
994                                    {
995                                      if (((word >> 31) & 0x1) == 0)
996                                        {
997                                          if (((word >> 30) & 0x1) == 0)
998                                            {
999                                              /* 33222222222211111111110000000000
1000                                                 10987654321098765432109876543210
1001                                                 0000100x110xxxxx0xxxxxxxxxxxxxxx
1002                                                 ldlarb.  */
1003                                              return 966;
1004                                            }
1005                                          else
1006                                            {
1007                                              /* 33222222222211111111110000000000
1008                                                 10987654321098765432109876543210
1009                                                 0100100x110xxxxx0xxxxxxxxxxxxxxx
1010                                                 ldlarh.  */
1011                                              return 967;
1012                                            }
1013                                        }
1014                                      else
1015                                        {
1016                                          /* 33222222222211111111110000000000
1017                                             10987654321098765432109876543210
1018                                             1x00100x110xxxxx0xxxxxxxxxxxxxxx
1019                                             ldlar.  */
1020                                          return 965;
1021                                        }
1022                                    }
1023                                  else
1024                                    {
1025                                      if (((word >> 31) & 0x1) == 0)
1026                                        {
1027                                          if (((word >> 30) & 0x1) == 0)
1028                                            {
1029                                              /* 33222222222211111111110000000000
1030                                                 10987654321098765432109876543210
1031                                                 0000100x111xxxxx0xxxxxxxxxxxxxxx
1032                                                 casab.  */
1033                                              return 1017;
1034                                            }
1035                                          else
1036                                            {
1037                                              /* 33222222222211111111110000000000
1038                                                 10987654321098765432109876543210
1039                                                 0100100x111xxxxx0xxxxxxxxxxxxxxx
1040                                                 casah.  */
1041                                              return 1020;
1042                                            }
1043                                        }
1044                                      else
1045                                        {
1046                                          /* 33222222222211111111110000000000
1047                                             10987654321098765432109876543210
1048                                             1x00100x111xxxxx0xxxxxxxxxxxxxxx
1049                                             casa.  */
1050                                          return 1023;
1051                                        }
1052                                    }
1053                                }
1054                              else
1055                                {
1056                                  if (((word >> 21) & 0x1) == 0)
1057                                    {
1058                                      if (((word >> 31) & 0x1) == 0)
1059                                        {
1060                                          if (((word >> 30) & 0x1) == 0)
1061                                            {
1062                                              /* 33222222222211111111110000000000
1063                                                 10987654321098765432109876543210
1064                                                 0000100x110xxxxx1xxxxxxxxxxxxxxx
1065                                                 ldarb.  */
1066                                              return 942;
1067                                            }
1068                                          else
1069                                            {
1070                                              /* 33222222222211111111110000000000
1071                                                 10987654321098765432109876543210
1072                                                 0100100x110xxxxx1xxxxxxxxxxxxxxx
1073                                                 ldarh.  */
1074                                              return 948;
1075                                            }
1076                                        }
1077                                      else
1078                                        {
1079                                          /* 33222222222211111111110000000000
1080                                             10987654321098765432109876543210
1081                                             1x00100x110xxxxx1xxxxxxxxxxxxxxx
1082                                             ldar.  */
1083                                          return 958;
1084                                        }
1085                                    }
1086                                  else
1087                                    {
1088                                      if (((word >> 31) & 0x1) == 0)
1089                                        {
1090                                          if (((word >> 30) & 0x1) == 0)
1091                                            {
1092                                              /* 33222222222211111111110000000000
1093                                                 10987654321098765432109876543210
1094                                                 0000100x111xxxxx1xxxxxxxxxxxxxxx
1095                                                 casalb.  */
1096                                              return 1019;
1097                                            }
1098                                          else
1099                                            {
1100                                              /* 33222222222211111111110000000000
1101                                                 10987654321098765432109876543210
1102                                                 0100100x111xxxxx1xxxxxxxxxxxxxxx
1103                                                 casalh.  */
1104                                              return 1022;
1105                                            }
1106                                        }
1107                                      else
1108                                        {
1109                                          /* 33222222222211111111110000000000
1110                                             10987654321098765432109876543210
1111                                             1x00100x111xxxxx1xxxxxxxxxxxxxxx
1112                                             casal.  */
1113                                          return 1025;
1114                                        }
1115                                    }
1116                                }
1117                            }
1118                          else
1119                            {
1120                              if (((word >> 30) & 0x1) == 0)
1121                                {
1122                                  /* 33222222222211111111110000000000
1123                                     10987654321098765432109876543210
1124                                     x010100x11xxxxxxxxxxxxxxxxxxxxxx
1125                                     ldp.  */
1126                                  return 982;
1127                                }
1128                              else
1129                                {
1130                                  /* 33222222222211111111110000000000
1131                                     10987654321098765432109876543210
1132                                     x110100x11xxxxxxxxxxxxxxxxxxxxxx
1133                                     ldpsw.  */
1134                                  return 985;
1135                                }
1136                            }
1137                        }
1138                    }
1139                }
1140              else
1141                {
1142                  if (((word >> 24) & 0x1) == 0)
1143                    {
1144                      if (((word >> 29) & 0x1) == 0)
1145                        {
1146                          if (((word >> 31) & 0x1) == 0)
1147                            {
1148                              /* 33222222222211111111110000000000
1149                                 10987654321098765432109876543210
1150                                 0x011000xxxxxxxxxxxxxxxxxxxxxxxx
1151                                 ldr.  */
1152                              return 987;
1153                            }
1154                          else
1155                            {
1156                              if (((word >> 30) & 0x1) == 0)
1157                                {
1158                                  /* 33222222222211111111110000000000
1159                                     10987654321098765432109876543210
1160                                     10011000xxxxxxxxxxxxxxxxxxxxxxxx
1161                                     ldrsw.  */
1162                                  return 989;
1163                                }
1164                              else
1165                                {
1166                                  /* 33222222222211111111110000000000
1167                                     10987654321098765432109876543210
1168                                     11011000xxxxxxxxxxxxxxxxxxxxxxxx
1169                                     prfm.  */
1170                                  return 990;
1171                                }
1172                            }
1173                        }
1174                      else
1175                        {
1176                          if (((word >> 10) & 0x1) == 0)
1177                            {
1178                              if (((word >> 11) & 0x1) == 0)
1179                                {
1180                                  if (((word >> 21) & 0x1) == 0)
1181                                    {
1182                                      if (((word >> 23) & 0x1) == 0)
1183                                        {
1184                                          if (((word >> 22) & 0x1) == 0)
1185                                            {
1186                                              if (((word >> 31) & 0x1) == 0)
1187                                                {
1188                                                  if (((word >> 30) & 0x1) == 0)
1189                                                    {
1190                                                      /* 33222222222211111111110000000000
1191                                                         10987654321098765432109876543210
1192                                                         00111000000xxxxxxxxx00xxxxxxxxxx
1193                                                         sturb.  */
1194                                                      return 922;
1195                                                    }
1196                                                  else
1197                                                    {
1198                                                      /* 33222222222211111111110000000000
1199                                                         10987654321098765432109876543210
1200                                                         01111000000xxxxxxxxx00xxxxxxxxxx
1201                                                         sturh.  */
1202                                                      return 927;
1203                                                    }
1204                                                }
1205                                              else
1206                                                {
1207                                                  /* 33222222222211111111110000000000
1208                                                     10987654321098765432109876543210
1209                                                     1x111000000xxxxxxxxx00xxxxxxxxxx
1210                                                     stur.  */
1211                                                  return 930;
1212                                                }
1213                                            }
1214                                          else
1215                                            {
1216                                              if (((word >> 31) & 0x1) == 0)
1217                                                {
1218                                                  if (((word >> 30) & 0x1) == 0)
1219                                                    {
1220                                                      /* 33222222222211111111110000000000
1221                                                         10987654321098765432109876543210
1222                                                         00111000010xxxxxxxxx00xxxxxxxxxx
1223                                                         ldurb.  */
1224                                                      return 923;
1225                                                    }
1226                                                  else
1227                                                    {
1228                                                      /* 33222222222211111111110000000000
1229                                                         10987654321098765432109876543210
1230                                                         01111000010xxxxxxxxx00xxxxxxxxxx
1231                                                         ldurh.  */
1232                                                      return 928;
1233                                                    }
1234                                                }
1235                                              else
1236                                                {
1237                                                  /* 33222222222211111111110000000000
1238                                                     10987654321098765432109876543210
1239                                                     1x111000010xxxxxxxxx00xxxxxxxxxx
1240                                                     ldur.  */
1241                                                  return 931;
1242                                                }
1243                                            }
1244                                        }
1245                                      else
1246                                        {
1247                                          if (((word >> 30) & 0x1) == 0)
1248                                            {
1249                                              if (((word >> 31) & 0x1) == 0)
1250                                                {
1251                                                  /* 33222222222211111111110000000000
1252                                                     10987654321098765432109876543210
1253                                                     001110001x0xxxxxxxxx00xxxxxxxxxx
1254                                                     ldursb.  */
1255                                                  return 924;
1256                                                }
1257                                              else
1258                                                {
1259                                                  /* 33222222222211111111110000000000
1260                                                     10987654321098765432109876543210
1261                                                     101110001x0xxxxxxxxx00xxxxxxxxxx
1262                                                     ldursw.  */
1263                                                  return 932;
1264                                                }
1265                                            }
1266                                          else
1267                                            {
1268                                              if (((word >> 31) & 0x1) == 0)
1269                                                {
1270                                                  /* 33222222222211111111110000000000
1271                                                     10987654321098765432109876543210
1272                                                     011110001x0xxxxxxxxx00xxxxxxxxxx
1273                                                     ldursh.  */
1274                                                  return 929;
1275                                                }
1276                                              else
1277                                                {
1278                                                  /* 33222222222211111111110000000000
1279                                                     10987654321098765432109876543210
1280                                                     111110001x0xxxxxxxxx00xxxxxxxxxx
1281                                                     prfum.  */
1282                                                  return 933;
1283                                                }
1284                                            }
1285                                        }
1286                                    }
1287                                  else
1288                                    {
1289                                      if (((word >> 12) & 0x1) == 0)
1290                                        {
1291                                          if (((word >> 13) & 0x1) == 0)
1292                                            {
1293                                              if (((word >> 14) & 0x1) == 0)
1294                                                {
1295                                                  if (((word >> 15) & 0x1) == 0)
1296                                                    {
1297                                                      if (((word >> 22) & 0x1) == 0)
1298                                                        {
1299                                                          if (((word >> 23) & 0x1) == 0)
1300                                                            {
1301                                                              if (((word >> 31) & 0x1) == 0)
1302                                                                {
1303                                                                  if (((word >> 30) & 0x1) == 0)
1304                                                                    {
1305                                                                      /* 33222222222211111111110000000000
1306                                                                         10987654321098765432109876543210
1307                                                                         00111000001xxxxx000000xxxxxxxxxx
1308                                                                         ldaddb.  */
1309                                                                      return 1042;
1310                                                                    }
1311                                                                  else
1312                                                                    {
1313                                                                      /* 33222222222211111111110000000000
1314                                                                         10987654321098765432109876543210
1315                                                                         01111000001xxxxx000000xxxxxxxxxx
1316                                                                         ldaddh.  */
1317                                                                      return 1043;
1318                                                                    }
1319                                                                }
1320                                                              else
1321                                                                {
1322                                                                  /* 33222222222211111111110000000000
1323                                                                     10987654321098765432109876543210
1324                                                                     1x111000001xxxxx000000xxxxxxxxxx
1325                                                                     ldadd.  */
1326                                                                  return 1044;
1327                                                                }
1328                                                            }
1329                                                          else
1330                                                            {
1331                                                              if (((word >> 31) & 0x1) == 0)
1332                                                                {
1333                                                                  if (((word >> 30) & 0x1) == 0)
1334                                                                    {
1335                                                                      /* 33222222222211111111110000000000
1336                                                                         10987654321098765432109876543210
1337                                                                         00111000101xxxxx000000xxxxxxxxxx
1338                                                                         ldaddab.  */
1339                                                                      return 1045;
1340                                                                    }
1341                                                                  else
1342                                                                    {
1343                                                                      /* 33222222222211111111110000000000
1344                                                                         10987654321098765432109876543210
1345                                                                         01111000101xxxxx000000xxxxxxxxxx
1346                                                                         ldaddah.  */
1347                                                                      return 1048;
1348                                                                    }
1349                                                                }
1350                                                              else
1351                                                                {
1352                                                                  /* 33222222222211111111110000000000
1353                                                                     10987654321098765432109876543210
1354                                                                     1x111000101xxxxx000000xxxxxxxxxx
1355                                                                     ldadda.  */
1356                                                                  return 1051;
1357                                                                }
1358                                                            }
1359                                                        }
1360                                                      else
1361                                                        {
1362                                                          if (((word >> 23) & 0x1) == 0)
1363                                                            {
1364                                                              if (((word >> 31) & 0x1) == 0)
1365                                                                {
1366                                                                  if (((word >> 30) & 0x1) == 0)
1367                                                                    {
1368                                                                      /* 33222222222211111111110000000000
1369                                                                         10987654321098765432109876543210
1370                                                                         00111000011xxxxx000000xxxxxxxxxx
1371                                                                         ldaddlb.  */
1372                                                                      return 1046;
1373                                                                    }
1374                                                                  else
1375                                                                    {
1376                                                                      /* 33222222222211111111110000000000
1377                                                                         10987654321098765432109876543210
1378                                                                         01111000011xxxxx000000xxxxxxxxxx
1379                                                                         ldaddlh.  */
1380                                                                      return 1049;
1381                                                                    }
1382                                                                }
1383                                                              else
1384                                                                {
1385                                                                  /* 33222222222211111111110000000000
1386                                                                     10987654321098765432109876543210
1387                                                                     1x111000011xxxxx000000xxxxxxxxxx
1388                                                                     ldaddl.  */
1389                                                                  return 1052;
1390                                                                }
1391                                                            }
1392                                                          else
1393                                                            {
1394                                                              if (((word >> 31) & 0x1) == 0)
1395                                                                {
1396                                                                  if (((word >> 30) & 0x1) == 0)
1397                                                                    {
1398                                                                      /* 33222222222211111111110000000000
1399                                                                         10987654321098765432109876543210
1400                                                                         00111000111xxxxx000000xxxxxxxxxx
1401                                                                         ldaddalb.  */
1402                                                                      return 1047;
1403                                                                    }
1404                                                                  else
1405                                                                    {
1406                                                                      /* 33222222222211111111110000000000
1407                                                                         10987654321098765432109876543210
1408                                                                         01111000111xxxxx000000xxxxxxxxxx
1409                                                                         ldaddalh.  */
1410                                                                      return 1050;
1411                                                                    }
1412                                                                }
1413                                                              else
1414                                                                {
1415                                                                  /* 33222222222211111111110000000000
1416                                                                     10987654321098765432109876543210
1417                                                                     1x111000111xxxxx000000xxxxxxxxxx
1418                                                                     ldaddal.  */
1419                                                                  return 1053;
1420                                                                }
1421                                                            }
1422                                                        }
1423                                                    }
1424                                                  else
1425                                                    {
1426                                                      if (((word >> 22) & 0x1) == 0)
1427                                                        {
1428                                                          if (((word >> 23) & 0x1) == 0)
1429                                                            {
1430                                                              if (((word >> 31) & 0x1) == 0)
1431                                                                {
1432                                                                  if (((word >> 30) & 0x1) == 0)
1433                                                                    {
1434                                                                      /* 33222222222211111111110000000000
1435                                                                         10987654321098765432109876543210
1436                                                                         00111000001xxxxx100000xxxxxxxxxx
1437                                                                         swpb.  */
1438                                                                      return 1030;
1439                                                                    }
1440                                                                  else
1441                                                                    {
1442                                                                      /* 33222222222211111111110000000000
1443                                                                         10987654321098765432109876543210
1444                                                                         01111000001xxxxx100000xxxxxxxxxx
1445                                                                         swph.  */
1446                                                                      return 1031;
1447                                                                    }
1448                                                                }
1449                                                              else
1450                                                                {
1451                                                                  /* 33222222222211111111110000000000
1452                                                                     10987654321098765432109876543210
1453                                                                     1x111000001xxxxx100000xxxxxxxxxx
1454                                                                     swp.  */
1455                                                                  return 1032;
1456                                                                }
1457                                                            }
1458                                                          else
1459                                                            {
1460                                                              if (((word >> 31) & 0x1) == 0)
1461                                                                {
1462                                                                  if (((word >> 30) & 0x1) == 0)
1463                                                                    {
1464                                                                      /* 33222222222211111111110000000000
1465                                                                         10987654321098765432109876543210
1466                                                                         00111000101xxxxx100000xxxxxxxxxx
1467                                                                         swpab.  */
1468                                                                      return 1033;
1469                                                                    }
1470                                                                  else
1471                                                                    {
1472                                                                      /* 33222222222211111111110000000000
1473                                                                         10987654321098765432109876543210
1474                                                                         01111000101xxxxx100000xxxxxxxxxx
1475                                                                         swpah.  */
1476                                                                      return 1036;
1477                                                                    }
1478                                                                }
1479                                                              else
1480                                                                {
1481                                                                  /* 33222222222211111111110000000000
1482                                                                     10987654321098765432109876543210
1483                                                                     1x111000101xxxxx100000xxxxxxxxxx
1484                                                                     swpa.  */
1485                                                                  return 1039;
1486                                                                }
1487                                                            }
1488                                                        }
1489                                                      else
1490                                                        {
1491                                                          if (((word >> 23) & 0x1) == 0)
1492                                                            {
1493                                                              if (((word >> 31) & 0x1) == 0)
1494                                                                {
1495                                                                  if (((word >> 30) & 0x1) == 0)
1496                                                                    {
1497                                                                      /* 33222222222211111111110000000000
1498                                                                         10987654321098765432109876543210
1499                                                                         00111000011xxxxx100000xxxxxxxxxx
1500                                                                         swplb.  */
1501                                                                      return 1034;
1502                                                                    }
1503                                                                  else
1504                                                                    {
1505                                                                      /* 33222222222211111111110000000000
1506                                                                         10987654321098765432109876543210
1507                                                                         01111000011xxxxx100000xxxxxxxxxx
1508                                                                         swplh.  */
1509                                                                      return 1037;
1510                                                                    }
1511                                                                }
1512                                                              else
1513                                                                {
1514                                                                  /* 33222222222211111111110000000000
1515                                                                     10987654321098765432109876543210
1516                                                                     1x111000011xxxxx100000xxxxxxxxxx
1517                                                                     swpl.  */
1518                                                                  return 1040;
1519                                                                }
1520                                                            }
1521                                                          else
1522                                                            {
1523                                                              if (((word >> 31) & 0x1) == 0)
1524                                                                {
1525                                                                  if (((word >> 30) & 0x1) == 0)
1526                                                                    {
1527                                                                      /* 33222222222211111111110000000000
1528                                                                         10987654321098765432109876543210
1529                                                                         00111000111xxxxx100000xxxxxxxxxx
1530                                                                         swpalb.  */
1531                                                                      return 1035;
1532                                                                    }
1533                                                                  else
1534                                                                    {
1535                                                                      /* 33222222222211111111110000000000
1536                                                                         10987654321098765432109876543210
1537                                                                         01111000111xxxxx100000xxxxxxxxxx
1538                                                                         swpalh.  */
1539                                                                      return 1038;
1540                                                                    }
1541                                                                }
1542                                                              else
1543                                                                {
1544                                                                  /* 33222222222211111111110000000000
1545                                                                     10987654321098765432109876543210
1546                                                                     1x111000111xxxxx100000xxxxxxxxxx
1547                                                                     swpal.  */
1548                                                                  return 1041;
1549                                                                }
1550                                                            }
1551                                                        }
1552                                                    }
1553                                                }
1554                                              else
1555                                                {
1556                                                  if (((word >> 15) & 0x1) == 0)
1557                                                    {
1558                                                      if (((word >> 22) & 0x1) == 0)
1559                                                        {
1560                                                          if (((word >> 23) & 0x1) == 0)
1561                                                            {
1562                                                              if (((word >> 31) & 0x1) == 0)
1563                                                                {
1564                                                                  if (((word >> 30) & 0x1) == 0)
1565                                                                    {
1566                                                                      /* 33222222222211111111110000000000
1567                                                                         10987654321098765432109876543210
1568                                                                         00111000001xxxxx010000xxxxxxxxxx
1569                                                                         ldsmaxb.  */
1570                                                                      return 1090;
1571                                                                    }
1572                                                                  else
1573                                                                    {
1574                                                                      /* 33222222222211111111110000000000
1575                                                                         10987654321098765432109876543210
1576                                                                         01111000001xxxxx010000xxxxxxxxxx
1577                                                                         ldsmaxh.  */
1578                                                                      return 1091;
1579                                                                    }
1580                                                                }
1581                                                              else
1582                                                                {
1583                                                                  /* 33222222222211111111110000000000
1584                                                                     10987654321098765432109876543210
1585                                                                     1x111000001xxxxx010000xxxxxxxxxx
1586                                                                     ldsmax.  */
1587                                                                  return 1092;
1588                                                                }
1589                                                            }
1590                                                          else
1591                                                            {
1592                                                              if (((word >> 31) & 0x1) == 0)
1593                                                                {
1594                                                                  if (((word >> 30) & 0x1) == 0)
1595                                                                    {
1596                                                                      /* 33222222222211111111110000000000
1597                                                                         10987654321098765432109876543210
1598                                                                         00111000101xxxxx010000xxxxxxxxxx
1599                                                                         ldsmaxab.  */
1600                                                                      return 1093;
1601                                                                    }
1602                                                                  else
1603                                                                    {
1604                                                                      /* 33222222222211111111110000000000
1605                                                                         10987654321098765432109876543210
1606                                                                         01111000101xxxxx010000xxxxxxxxxx
1607                                                                         ldsmaxah.  */
1608                                                                      return 1096;
1609                                                                    }
1610                                                                }
1611                                                              else
1612                                                                {
1613                                                                  /* 33222222222211111111110000000000
1614                                                                     10987654321098765432109876543210
1615                                                                     1x111000101xxxxx010000xxxxxxxxxx
1616                                                                     ldsmaxa.  */
1617                                                                  return 1099;
1618                                                                }
1619                                                            }
1620                                                        }
1621                                                      else
1622                                                        {
1623                                                          if (((word >> 23) & 0x1) == 0)
1624                                                            {
1625                                                              if (((word >> 31) & 0x1) == 0)
1626                                                                {
1627                                                                  if (((word >> 30) & 0x1) == 0)
1628                                                                    {
1629                                                                      /* 33222222222211111111110000000000
1630                                                                         10987654321098765432109876543210
1631                                                                         00111000011xxxxx010000xxxxxxxxxx
1632                                                                         ldsmaxlb.  */
1633                                                                      return 1094;
1634                                                                    }
1635                                                                  else
1636                                                                    {
1637                                                                      /* 33222222222211111111110000000000
1638                                                                         10987654321098765432109876543210
1639                                                                         01111000011xxxxx010000xxxxxxxxxx
1640                                                                         ldsmaxlh.  */
1641                                                                      return 1097;
1642                                                                    }
1643                                                                }
1644                                                              else
1645                                                                {
1646                                                                  /* 33222222222211111111110000000000
1647                                                                     10987654321098765432109876543210
1648                                                                     1x111000011xxxxx010000xxxxxxxxxx
1649                                                                     ldsmaxl.  */
1650                                                                  return 1100;
1651                                                                }
1652                                                            }
1653                                                          else
1654                                                            {
1655                                                              if (((word >> 31) & 0x1) == 0)
1656                                                                {
1657                                                                  if (((word >> 30) & 0x1) == 0)
1658                                                                    {
1659                                                                      /* 33222222222211111111110000000000
1660                                                                         10987654321098765432109876543210
1661                                                                         00111000111xxxxx010000xxxxxxxxxx
1662                                                                         ldsmaxalb.  */
1663                                                                      return 1095;
1664                                                                    }
1665                                                                  else
1666                                                                    {
1667                                                                      /* 33222222222211111111110000000000
1668                                                                         10987654321098765432109876543210
1669                                                                         01111000111xxxxx010000xxxxxxxxxx
1670                                                                         ldsmaxalh.  */
1671                                                                      return 1098;
1672                                                                    }
1673                                                                }
1674                                                              else
1675                                                                {
1676                                                                  /* 33222222222211111111110000000000
1677                                                                     10987654321098765432109876543210
1678                                                                     1x111000111xxxxx010000xxxxxxxxxx
1679                                                                     ldsmaxal.  */
1680                                                                  return 1101;
1681                                                                }
1682                                                            }
1683                                                        }
1684                                                    }
1685                                                  else
1686                                                    {
1687                                                      if (((word >> 31) & 0x1) == 0)
1688                                                        {
1689                                                          if (((word >> 30) & 0x1) == 0)
1690                                                            {
1691                                                              /* 33222222222211111111110000000000
1692                                                                 10987654321098765432109876543210
1693                                                                 00111000xx1xxxxx110000xxxxxxxxxx
1694                                                                 ldaprb.  */
1695                                                              return 959;
1696                                                            }
1697                                                          else
1698                                                            {
1699                                                              /* 33222222222211111111110000000000
1700                                                                 10987654321098765432109876543210
1701                                                                 01111000xx1xxxxx110000xxxxxxxxxx
1702                                                                 ldaprh.  */
1703                                                              return 960;
1704                                                            }
1705                                                        }
1706                                                      else
1707                                                        {
1708                                                          /* 33222222222211111111110000000000
1709                                                             10987654321098765432109876543210
1710                                                             1x111000xx1xxxxx110000xxxxxxxxxx
1711                                                             ldapr.  */
1712                                                          return 961;
1713                                                        }
1714                                                    }
1715                                                }
1716                                            }
1717                                          else
1718                                            {
1719                                              if (((word >> 14) & 0x1) == 0)
1720                                                {
1721                                                  if (((word >> 15) & 0x1) == 0)
1722                                                    {
1723                                                      if (((word >> 22) & 0x1) == 0)
1724                                                        {
1725                                                          if (((word >> 23) & 0x1) == 0)
1726                                                            {
1727                                                              if (((word >> 31) & 0x1) == 0)
1728                                                                {
1729                                                                  if (((word >> 30) & 0x1) == 0)
1730                                                                    {
1731                                                                      /* 33222222222211111111110000000000
1732                                                                         10987654321098765432109876543210
1733                                                                         00111000001xxxxx001000xxxxxxxxxx
1734                                                                         ldeorb.  */
1735                                                                      return 1066;
1736                                                                    }
1737                                                                  else
1738                                                                    {
1739                                                                      /* 33222222222211111111110000000000
1740                                                                         10987654321098765432109876543210
1741                                                                         01111000001xxxxx001000xxxxxxxxxx
1742                                                                         ldeorh.  */
1743                                                                      return 1067;
1744                                                                    }
1745                                                                }
1746                                                              else
1747                                                                {
1748                                                                  /* 33222222222211111111110000000000
1749                                                                     10987654321098765432109876543210
1750                                                                     1x111000001xxxxx001000xxxxxxxxxx
1751                                                                     ldeor.  */
1752                                                                  return 1068;
1753                                                                }
1754                                                            }
1755                                                          else
1756                                                            {
1757                                                              if (((word >> 31) & 0x1) == 0)
1758                                                                {
1759                                                                  if (((word >> 30) & 0x1) == 0)
1760                                                                    {
1761                                                                      /* 33222222222211111111110000000000
1762                                                                         10987654321098765432109876543210
1763                                                                         00111000101xxxxx001000xxxxxxxxxx
1764                                                                         ldeorab.  */
1765                                                                      return 1069;
1766                                                                    }
1767                                                                  else
1768                                                                    {
1769                                                                      /* 33222222222211111111110000000000
1770                                                                         10987654321098765432109876543210
1771                                                                         01111000101xxxxx001000xxxxxxxxxx
1772                                                                         ldeorah.  */
1773                                                                      return 1072;
1774                                                                    }
1775                                                                }
1776                                                              else
1777                                                                {
1778                                                                  /* 33222222222211111111110000000000
1779                                                                     10987654321098765432109876543210
1780                                                                     1x111000101xxxxx001000xxxxxxxxxx
1781                                                                     ldeora.  */
1782                                                                  return 1075;
1783                                                                }
1784                                                            }
1785                                                        }
1786                                                      else
1787                                                        {
1788                                                          if (((word >> 23) & 0x1) == 0)
1789                                                            {
1790                                                              if (((word >> 31) & 0x1) == 0)
1791                                                                {
1792                                                                  if (((word >> 30) & 0x1) == 0)
1793                                                                    {
1794                                                                      /* 33222222222211111111110000000000
1795                                                                         10987654321098765432109876543210
1796                                                                         00111000011xxxxx001000xxxxxxxxxx
1797                                                                         ldeorlb.  */
1798                                                                      return 1070;
1799                                                                    }
1800                                                                  else
1801                                                                    {
1802                                                                      /* 33222222222211111111110000000000
1803                                                                         10987654321098765432109876543210
1804                                                                         01111000011xxxxx001000xxxxxxxxxx
1805                                                                         ldeorlh.  */
1806                                                                      return 1073;
1807                                                                    }
1808                                                                }
1809                                                              else
1810                                                                {
1811                                                                  /* 33222222222211111111110000000000
1812                                                                     10987654321098765432109876543210
1813                                                                     1x111000011xxxxx001000xxxxxxxxxx
1814                                                                     ldeorl.  */
1815                                                                  return 1076;
1816                                                                }
1817                                                            }
1818                                                          else
1819                                                            {
1820                                                              if (((word >> 31) & 0x1) == 0)
1821                                                                {
1822                                                                  if (((word >> 30) & 0x1) == 0)
1823                                                                    {
1824                                                                      /* 33222222222211111111110000000000
1825                                                                         10987654321098765432109876543210
1826                                                                         00111000111xxxxx001000xxxxxxxxxx
1827                                                                         ldeoralb.  */
1828                                                                      return 1071;
1829                                                                    }
1830                                                                  else
1831                                                                    {
1832                                                                      /* 33222222222211111111110000000000
1833                                                                         10987654321098765432109876543210
1834                                                                         01111000111xxxxx001000xxxxxxxxxx
1835                                                                         ldeoralh.  */
1836                                                                      return 1074;
1837                                                                    }
1838                                                                }
1839                                                              else
1840                                                                {
1841                                                                  /* 33222222222211111111110000000000
1842                                                                     10987654321098765432109876543210
1843                                                                     1x111000111xxxxx001000xxxxxxxxxx
1844                                                                     ldeoral.  */
1845                                                                  return 1077;
1846                                                                }
1847                                                            }
1848                                                        }
1849                                                    }
1850                                                  else
1851                                                    {
1852                                                      /* 33222222222211111111110000000000
1853                                                         10987654321098765432109876543210
1854                                                         xx111000xx1xxxxx101000xxxxxxxxxx
1855                                                         st64bv0.  */
1856                                                      return 994;
1857                                                    }
1858                                                }
1859                                              else
1860                                                {
1861                                                  if (((word >> 22) & 0x1) == 0)
1862                                                    {
1863                                                      if (((word >> 23) & 0x1) == 0)
1864                                                        {
1865                                                          if (((word >> 31) & 0x1) == 0)
1866                                                            {
1867                                                              if (((word >> 30) & 0x1) == 0)
1868                                                                {
1869                                                                  /* 33222222222211111111110000000000
1870                                                                     10987654321098765432109876543210
1871                                                                     00111000001xxxxxx11000xxxxxxxxxx
1872                                                                     ldumaxb.  */
1873                                                                  return 1114;
1874                                                                }
1875                                                              else
1876                                                                {
1877                                                                  /* 33222222222211111111110000000000
1878                                                                     10987654321098765432109876543210
1879                                                                     01111000001xxxxxx11000xxxxxxxxxx
1880                                                                     ldumaxh.  */
1881                                                                  return 1115;
1882                                                                }
1883                                                            }
1884                                                          else
1885                                                            {
1886                                                              /* 33222222222211111111110000000000
1887                                                                 10987654321098765432109876543210
1888                                                                 1x111000001xxxxxx11000xxxxxxxxxx
1889                                                                 ldumax.  */
1890                                                              return 1116;
1891                                                            }
1892                                                        }
1893                                                      else
1894                                                        {
1895                                                          if (((word >> 31) & 0x1) == 0)
1896                                                            {
1897                                                              if (((word >> 30) & 0x1) == 0)
1898                                                                {
1899                                                                  /* 33222222222211111111110000000000
1900                                                                     10987654321098765432109876543210
1901                                                                     00111000101xxxxxx11000xxxxxxxxxx
1902                                                                     ldumaxab.  */
1903                                                                  return 1117;
1904                                                                }
1905                                                              else
1906                                                                {
1907                                                                  /* 33222222222211111111110000000000
1908                                                                     10987654321098765432109876543210
1909                                                                     01111000101xxxxxx11000xxxxxxxxxx
1910                                                                     ldumaxah.  */
1911                                                                  return 1120;
1912                                                                }
1913                                                            }
1914                                                          else
1915                                                            {
1916                                                              /* 33222222222211111111110000000000
1917                                                                 10987654321098765432109876543210
1918                                                                 1x111000101xxxxxx11000xxxxxxxxxx
1919                                                                 ldumaxa.  */
1920                                                              return 1123;
1921                                                            }
1922                                                        }
1923                                                    }
1924                                                  else
1925                                                    {
1926                                                      if (((word >> 23) & 0x1) == 0)
1927                                                        {
1928                                                          if (((word >> 31) & 0x1) == 0)
1929                                                            {
1930                                                              if (((word >> 30) & 0x1) == 0)
1931                                                                {
1932                                                                  /* 33222222222211111111110000000000
1933                                                                     10987654321098765432109876543210
1934                                                                     00111000011xxxxxx11000xxxxxxxxxx
1935                                                                     ldumaxlb.  */
1936                                                                  return 1118;
1937                                                                }
1938                                                              else
1939                                                                {
1940                                                                  /* 33222222222211111111110000000000
1941                                                                     10987654321098765432109876543210
1942                                                                     01111000011xxxxxx11000xxxxxxxxxx
1943                                                                     ldumaxlh.  */
1944                                                                  return 1121;
1945                                                                }
1946                                                            }
1947                                                          else
1948                                                            {
1949                                                              /* 33222222222211111111110000000000
1950                                                                 10987654321098765432109876543210
1951                                                                 1x111000011xxxxxx11000xxxxxxxxxx
1952                                                                 ldumaxl.  */
1953                                                              return 1124;
1954                                                            }
1955                                                        }
1956                                                      else
1957                                                        {
1958                                                          if (((word >> 31) & 0x1) == 0)
1959                                                            {
1960                                                              if (((word >> 30) & 0x1) == 0)
1961                                                                {
1962                                                                  /* 33222222222211111111110000000000
1963                                                                     10987654321098765432109876543210
1964                                                                     00111000111xxxxxx11000xxxxxxxxxx
1965                                                                     ldumaxalb.  */
1966                                                                  return 1119;
1967                                                                }
1968                                                              else
1969                                                                {
1970                                                                  /* 33222222222211111111110000000000
1971                                                                     10987654321098765432109876543210
1972                                                                     01111000111xxxxxx11000xxxxxxxxxx
1973                                                                     ldumaxalh.  */
1974                                                                  return 1122;
1975                                                                }
1976                                                            }
1977                                                          else
1978                                                            {
1979                                                              /* 33222222222211111111110000000000
1980                                                                 10987654321098765432109876543210
1981                                                                 1x111000111xxxxxx11000xxxxxxxxxx
1982                                                                 ldumaxal.  */
1983                                                              return 1125;
1984                                                            }
1985                                                        }
1986                                                    }
1987                                                }
1988                                            }
1989                                        }
1990                                      else
1991                                        {
1992                                          if (((word >> 13) & 0x1) == 0)
1993                                            {
1994                                              if (((word >> 14) & 0x1) == 0)
1995                                                {
1996                                                  if (((word >> 15) & 0x1) == 0)
1997                                                    {
1998                                                      if (((word >> 22) & 0x1) == 0)
1999                                                        {
2000                                                          if (((word >> 23) & 0x1) == 0)
2001                                                            {
2002                                                              if (((word >> 31) & 0x1) == 0)
2003                                                                {
2004                                                                  if (((word >> 30) & 0x1) == 0)
2005                                                                    {
2006                                                                      /* 33222222222211111111110000000000
2007                                                                         10987654321098765432109876543210
2008                                                                         00111000001xxxxx000100xxxxxxxxxx
2009                                                                         ldclrb.  */
2010                                                                      return 1054;
2011                                                                    }
2012                                                                  else
2013                                                                    {
2014                                                                      /* 33222222222211111111110000000000
2015                                                                         10987654321098765432109876543210
2016                                                                         01111000001xxxxx000100xxxxxxxxxx
2017                                                                         ldclrh.  */
2018                                                                      return 1055;
2019                                                                    }
2020                                                                }
2021                                                              else
2022                                                                {
2023                                                                  /* 33222222222211111111110000000000
2024                                                                     10987654321098765432109876543210
2025                                                                     1x111000001xxxxx000100xxxxxxxxxx
2026                                                                     ldclr.  */
2027                                                                  return 1056;
2028                                                                }
2029                                                            }
2030                                                          else
2031                                                            {
2032                                                              if (((word >> 31) & 0x1) == 0)
2033                                                                {
2034                                                                  if (((word >> 30) & 0x1) == 0)
2035                                                                    {
2036                                                                      /* 33222222222211111111110000000000
2037                                                                         10987654321098765432109876543210
2038                                                                         00111000101xxxxx000100xxxxxxxxxx
2039                                                                         ldclrab.  */
2040                                                                      return 1057;
2041                                                                    }
2042                                                                  else
2043                                                                    {
2044                                                                      /* 33222222222211111111110000000000
2045                                                                         10987654321098765432109876543210
2046                                                                         01111000101xxxxx000100xxxxxxxxxx
2047                                                                         ldclrah.  */
2048                                                                      return 1060;
2049                                                                    }
2050                                                                }
2051                                                              else
2052                                                                {
2053                                                                  /* 33222222222211111111110000000000
2054                                                                     10987654321098765432109876543210
2055                                                                     1x111000101xxxxx000100xxxxxxxxxx
2056                                                                     ldclra.  */
2057                                                                  return 1063;
2058                                                                }
2059                                                            }
2060                                                        }
2061                                                      else
2062                                                        {
2063                                                          if (((word >> 23) & 0x1) == 0)
2064                                                            {
2065                                                              if (((word >> 31) & 0x1) == 0)
2066                                                                {
2067                                                                  if (((word >> 30) & 0x1) == 0)
2068                                                                    {
2069                                                                      /* 33222222222211111111110000000000
2070                                                                         10987654321098765432109876543210
2071                                                                         00111000011xxxxx000100xxxxxxxxxx
2072                                                                         ldclrlb.  */
2073                                                                      return 1058;
2074                                                                    }
2075                                                                  else
2076                                                                    {
2077                                                                      /* 33222222222211111111110000000000
2078                                                                         10987654321098765432109876543210
2079                                                                         01111000011xxxxx000100xxxxxxxxxx
2080                                                                         ldclrlh.  */
2081                                                                      return 1061;
2082                                                                    }
2083                                                                }
2084                                                              else
2085                                                                {
2086                                                                  /* 33222222222211111111110000000000
2087                                                                     10987654321098765432109876543210
2088                                                                     1x111000011xxxxx000100xxxxxxxxxx
2089                                                                     ldclrl.  */
2090                                                                  return 1064;
2091                                                                }
2092                                                            }
2093                                                          else
2094                                                            {
2095                                                              if (((word >> 31) & 0x1) == 0)
2096                                                                {
2097                                                                  if (((word >> 30) & 0x1) == 0)
2098                                                                    {
2099                                                                      /* 33222222222211111111110000000000
2100                                                                         10987654321098765432109876543210
2101                                                                         00111000111xxxxx000100xxxxxxxxxx
2102                                                                         ldclralb.  */
2103                                                                      return 1059;
2104                                                                    }
2105                                                                  else
2106                                                                    {
2107                                                                      /* 33222222222211111111110000000000
2108                                                                         10987654321098765432109876543210
2109                                                                         01111000111xxxxx000100xxxxxxxxxx
2110                                                                         ldclralh.  */
2111                                                                      return 1062;
2112                                                                    }
2113                                                                }
2114                                                              else
2115                                                                {
2116                                                                  /* 33222222222211111111110000000000
2117                                                                     10987654321098765432109876543210
2118                                                                     1x111000111xxxxx000100xxxxxxxxxx
2119                                                                     ldclral.  */
2120                                                                  return 1065;
2121                                                                }
2122                                                            }
2123                                                        }
2124                                                    }
2125                                                  else
2126                                                    {
2127                                                      /* 33222222222211111111110000000000
2128                                                         10987654321098765432109876543210
2129                                                         xx111000xx1xxxxx100100xxxxxxxxxx
2130                                                         st64b.  */
2131                                                      return 992;
2132                                                    }
2133                                                }
2134                                              else
2135                                                {
2136                                                  if (((word >> 15) & 0x1) == 0)
2137                                                    {
2138                                                      if (((word >> 22) & 0x1) == 0)
2139                                                        {
2140                                                          if (((word >> 23) & 0x1) == 0)
2141                                                            {
2142                                                              if (((word >> 31) & 0x1) == 0)
2143                                                                {
2144                                                                  if (((word >> 30) & 0x1) == 0)
2145                                                                    {
2146                                                                      /* 33222222222211111111110000000000
2147                                                                         10987654321098765432109876543210
2148                                                                         00111000001xxxxx010100xxxxxxxxxx
2149                                                                         ldsminb.  */
2150                                                                      return 1102;
2151                                                                    }
2152                                                                  else
2153                                                                    {
2154                                                                      /* 33222222222211111111110000000000
2155                                                                         10987654321098765432109876543210
2156                                                                         01111000001xxxxx010100xxxxxxxxxx
2157                                                                         ldsminh.  */
2158                                                                      return 1103;
2159                                                                    }
2160                                                                }
2161                                                              else
2162                                                                {
2163                                                                  /* 33222222222211111111110000000000
2164                                                                     10987654321098765432109876543210
2165                                                                     1x111000001xxxxx010100xxxxxxxxxx
2166                                                                     ldsmin.  */
2167                                                                  return 1104;
2168                                                                }
2169                                                            }
2170                                                          else
2171                                                            {
2172                                                              if (((word >> 31) & 0x1) == 0)
2173                                                                {
2174                                                                  if (((word >> 30) & 0x1) == 0)
2175                                                                    {
2176                                                                      /* 33222222222211111111110000000000
2177                                                                         10987654321098765432109876543210
2178                                                                         00111000101xxxxx010100xxxxxxxxxx
2179                                                                         ldsminab.  */
2180                                                                      return 1105;
2181                                                                    }
2182                                                                  else
2183                                                                    {
2184                                                                      /* 33222222222211111111110000000000
2185                                                                         10987654321098765432109876543210
2186                                                                         01111000101xxxxx010100xxxxxxxxxx
2187                                                                         ldsminah.  */
2188                                                                      return 1108;
2189                                                                    }
2190                                                                }
2191                                                              else
2192                                                                {
2193                                                                  /* 33222222222211111111110000000000
2194                                                                     10987654321098765432109876543210
2195                                                                     1x111000101xxxxx010100xxxxxxxxxx
2196                                                                     ldsmina.  */
2197                                                                  return 1111;
2198                                                                }
2199                                                            }
2200                                                        }
2201                                                      else
2202                                                        {
2203                                                          if (((word >> 23) & 0x1) == 0)
2204                                                            {
2205                                                              if (((word >> 31) & 0x1) == 0)
2206                                                                {
2207                                                                  if (((word >> 30) & 0x1) == 0)
2208                                                                    {
2209                                                                      /* 33222222222211111111110000000000
2210                                                                         10987654321098765432109876543210
2211                                                                         00111000011xxxxx010100xxxxxxxxxx
2212                                                                         ldsminlb.  */
2213                                                                      return 1106;
2214                                                                    }
2215                                                                  else
2216                                                                    {
2217                                                                      /* 33222222222211111111110000000000
2218                                                                         10987654321098765432109876543210
2219                                                                         01111000011xxxxx010100xxxxxxxxxx
2220                                                                         ldsminlh.  */
2221                                                                      return 1109;
2222                                                                    }
2223                                                                }
2224                                                              else
2225                                                                {
2226                                                                  /* 33222222222211111111110000000000
2227                                                                     10987654321098765432109876543210
2228                                                                     1x111000011xxxxx010100xxxxxxxxxx
2229                                                                     ldsminl.  */
2230                                                                  return 1112;
2231                                                                }
2232                                                            }
2233                                                          else
2234                                                            {
2235                                                              if (((word >> 31) & 0x1) == 0)
2236                                                                {
2237                                                                  if (((word >> 30) & 0x1) == 0)
2238                                                                    {
2239                                                                      /* 33222222222211111111110000000000
2240                                                                         10987654321098765432109876543210
2241                                                                         00111000111xxxxx010100xxxxxxxxxx
2242                                                                         ldsminalb.  */
2243                                                                      return 1107;
2244                                                                    }
2245                                                                  else
2246                                                                    {
2247                                                                      /* 33222222222211111111110000000000
2248                                                                         10987654321098765432109876543210
2249                                                                         01111000111xxxxx010100xxxxxxxxxx
2250                                                                         ldsminalh.  */
2251                                                                      return 1110;
2252                                                                    }
2253                                                                }
2254                                                              else
2255                                                                {
2256                                                                  /* 33222222222211111111110000000000
2257                                                                     10987654321098765432109876543210
2258                                                                     1x111000111xxxxx010100xxxxxxxxxx
2259                                                                     ldsminal.  */
2260                                                                  return 1113;
2261                                                                }
2262                                                            }
2263                                                        }
2264                                                    }
2265                                                  else
2266                                                    {
2267                                                      /* 33222222222211111111110000000000
2268                                                         10987654321098765432109876543210
2269                                                         xx111000xx1xxxxx110100xxxxxxxxxx
2270                                                         ld64b.  */
2271                                                      return 991;
2272                                                    }
2273                                                }
2274                                            }
2275                                          else
2276                                            {
2277                                              if (((word >> 14) & 0x1) == 0)
2278                                                {
2279                                                  if (((word >> 15) & 0x1) == 0)
2280                                                    {
2281                                                      if (((word >> 22) & 0x1) == 0)
2282                                                        {
2283                                                          if (((word >> 23) & 0x1) == 0)
2284                                                            {
2285                                                              if (((word >> 31) & 0x1) == 0)
2286                                                                {
2287                                                                  if (((word >> 30) & 0x1) == 0)
2288                                                                    {
2289                                                                      /* 33222222222211111111110000000000
2290                                                                         10987654321098765432109876543210
2291                                                                         00111000001xxxxx001100xxxxxxxxxx
2292                                                                         ldsetb.  */
2293                                                                      return 1078;
2294                                                                    }
2295                                                                  else
2296                                                                    {
2297                                                                      /* 33222222222211111111110000000000
2298                                                                         10987654321098765432109876543210
2299                                                                         01111000001xxxxx001100xxxxxxxxxx
2300                                                                         ldseth.  */
2301                                                                      return 1079;
2302                                                                    }
2303                                                                }
2304                                                              else
2305                                                                {
2306                                                                  /* 33222222222211111111110000000000
2307                                                                     10987654321098765432109876543210
2308                                                                     1x111000001xxxxx001100xxxxxxxxxx
2309                                                                     ldset.  */
2310                                                                  return 1080;
2311                                                                }
2312                                                            }
2313                                                          else
2314                                                            {
2315                                                              if (((word >> 31) & 0x1) == 0)
2316                                                                {
2317                                                                  if (((word >> 30) & 0x1) == 0)
2318                                                                    {
2319                                                                      /* 33222222222211111111110000000000
2320                                                                         10987654321098765432109876543210
2321                                                                         00111000101xxxxx001100xxxxxxxxxx
2322                                                                         ldsetab.  */
2323                                                                      return 1081;
2324                                                                    }
2325                                                                  else
2326                                                                    {
2327                                                                      /* 33222222222211111111110000000000
2328                                                                         10987654321098765432109876543210
2329                                                                         01111000101xxxxx001100xxxxxxxxxx
2330                                                                         ldsetah.  */
2331                                                                      return 1084;
2332                                                                    }
2333                                                                }
2334                                                              else
2335                                                                {
2336                                                                  /* 33222222222211111111110000000000
2337                                                                     10987654321098765432109876543210
2338                                                                     1x111000101xxxxx001100xxxxxxxxxx
2339                                                                     ldseta.  */
2340                                                                  return 1087;
2341                                                                }
2342                                                            }
2343                                                        }
2344                                                      else
2345                                                        {
2346                                                          if (((word >> 23) & 0x1) == 0)
2347                                                            {
2348                                                              if (((word >> 31) & 0x1) == 0)
2349                                                                {
2350                                                                  if (((word >> 30) & 0x1) == 0)
2351                                                                    {
2352                                                                      /* 33222222222211111111110000000000
2353                                                                         10987654321098765432109876543210
2354                                                                         00111000011xxxxx001100xxxxxxxxxx
2355                                                                         ldsetlb.  */
2356                                                                      return 1082;
2357                                                                    }
2358                                                                  else
2359                                                                    {
2360                                                                      /* 33222222222211111111110000000000
2361                                                                         10987654321098765432109876543210
2362                                                                         01111000011xxxxx001100xxxxxxxxxx
2363                                                                         ldsetlh.  */
2364                                                                      return 1085;
2365                                                                    }
2366                                                                }
2367                                                              else
2368                                                                {
2369                                                                  /* 33222222222211111111110000000000
2370                                                                     10987654321098765432109876543210
2371                                                                     1x111000011xxxxx001100xxxxxxxxxx
2372                                                                     ldsetl.  */
2373                                                                  return 1088;
2374                                                                }
2375                                                            }
2376                                                          else
2377                                                            {
2378                                                              if (((word >> 31) & 0x1) == 0)
2379                                                                {
2380                                                                  if (((word >> 30) & 0x1) == 0)
2381                                                                    {
2382                                                                      /* 33222222222211111111110000000000
2383                                                                         10987654321098765432109876543210
2384                                                                         00111000111xxxxx001100xxxxxxxxxx
2385                                                                         ldsetalb.  */
2386                                                                      return 1083;
2387                                                                    }
2388                                                                  else
2389                                                                    {
2390                                                                      /* 33222222222211111111110000000000
2391                                                                         10987654321098765432109876543210
2392                                                                         01111000111xxxxx001100xxxxxxxxxx
2393                                                                         ldsetalh.  */
2394                                                                      return 1086;
2395                                                                    }
2396                                                                }
2397                                                              else
2398                                                                {
2399                                                                  /* 33222222222211111111110000000000
2400                                                                     10987654321098765432109876543210
2401                                                                     1x111000111xxxxx001100xxxxxxxxxx
2402                                                                     ldsetal.  */
2403                                                                  return 1089;
2404                                                                }
2405                                                            }
2406                                                        }
2407                                                    }
2408                                                  else
2409                                                    {
2410                                                      /* 33222222222211111111110000000000
2411                                                         10987654321098765432109876543210
2412                                                         xx111000xx1xxxxx101100xxxxxxxxxx
2413                                                         st64bv.  */
2414                                                      return 993;
2415                                                    }
2416                                                }
2417                                              else
2418                                                {
2419                                                  if (((word >> 22) & 0x1) == 0)
2420                                                    {
2421                                                      if (((word >> 23) & 0x1) == 0)
2422                                                        {
2423                                                          if (((word >> 31) & 0x1) == 0)
2424                                                            {
2425                                                              if (((word >> 30) & 0x1) == 0)
2426                                                                {
2427                                                                  /* 33222222222211111111110000000000
2428                                                                     10987654321098765432109876543210
2429                                                                     00111000001xxxxxx11100xxxxxxxxxx
2430                                                                     lduminb.  */
2431                                                                  return 1126;
2432                                                                }
2433                                                              else
2434                                                                {
2435                                                                  /* 33222222222211111111110000000000
2436                                                                     10987654321098765432109876543210
2437                                                                     01111000001xxxxxx11100xxxxxxxxxx
2438                                                                     lduminh.  */
2439                                                                  return 1127;
2440                                                                }
2441                                                            }
2442                                                          else
2443                                                            {
2444                                                              /* 33222222222211111111110000000000
2445                                                                 10987654321098765432109876543210
2446                                                                 1x111000001xxxxxx11100xxxxxxxxxx
2447                                                                 ldumin.  */
2448                                                              return 1128;
2449                                                            }
2450                                                        }
2451                                                      else
2452                                                        {
2453                                                          if (((word >> 31) & 0x1) == 0)
2454                                                            {
2455                                                              if (((word >> 30) & 0x1) == 0)
2456                                                                {
2457                                                                  /* 33222222222211111111110000000000
2458                                                                     10987654321098765432109876543210
2459                                                                     00111000101xxxxxx11100xxxxxxxxxx
2460                                                                     lduminab.  */
2461                                                                  return 1129;
2462                                                                }
2463                                                              else
2464                                                                {
2465                                                                  /* 33222222222211111111110000000000
2466                                                                     10987654321098765432109876543210
2467                                                                     01111000101xxxxxx11100xxxxxxxxxx
2468                                                                     lduminah.  */
2469                                                                  return 1132;
2470                                                                }
2471                                                            }
2472                                                          else
2473                                                            {
2474                                                              /* 33222222222211111111110000000000
2475                                                                 10987654321098765432109876543210
2476                                                                 1x111000101xxxxxx11100xxxxxxxxxx
2477                                                                 ldumina.  */
2478                                                              return 1135;
2479                                                            }
2480                                                        }
2481                                                    }
2482                                                  else
2483                                                    {
2484                                                      if (((word >> 23) & 0x1) == 0)
2485                                                        {
2486                                                          if (((word >> 31) & 0x1) == 0)
2487                                                            {
2488                                                              if (((word >> 30) & 0x1) == 0)
2489                                                                {
2490                                                                  /* 33222222222211111111110000000000
2491                                                                     10987654321098765432109876543210
2492                                                                     00111000011xxxxxx11100xxxxxxxxxx
2493                                                                     lduminlb.  */
2494                                                                  return 1130;
2495                                                                }
2496                                                              else
2497                                                                {
2498                                                                  /* 33222222222211111111110000000000
2499                                                                     10987654321098765432109876543210
2500                                                                     01111000011xxxxxx11100xxxxxxxxxx
2501                                                                     lduminlh.  */
2502                                                                  return 1133;
2503                                                                }
2504                                                            }
2505                                                          else
2506                                                            {
2507                                                              /* 33222222222211111111110000000000
2508                                                                 10987654321098765432109876543210
2509                                                                 1x111000011xxxxxx11100xxxxxxxxxx
2510                                                                 lduminl.  */
2511                                                              return 1136;
2512                                                            }
2513                                                        }
2514                                                      else
2515                                                        {
2516                                                          if (((word >> 31) & 0x1) == 0)
2517                                                            {
2518                                                              if (((word >> 30) & 0x1) == 0)
2519                                                                {
2520                                                                  /* 33222222222211111111110000000000
2521                                                                     10987654321098765432109876543210
2522                                                                     00111000111xxxxxx11100xxxxxxxxxx
2523                                                                     lduminalb.  */
2524                                                                  return 1131;
2525                                                                }
2526                                                              else
2527                                                                {
2528                                                                  /* 33222222222211111111110000000000
2529                                                                     10987654321098765432109876543210
2530                                                                     01111000111xxxxxx11100xxxxxxxxxx
2531                                                                     lduminalh.  */
2532                                                                  return 1134;
2533                                                                }
2534                                                            }
2535                                                          else
2536                                                            {
2537                                                              /* 33222222222211111111110000000000
2538                                                                 10987654321098765432109876543210
2539                                                                 1x111000111xxxxxx11100xxxxxxxxxx
2540                                                                 lduminal.  */
2541                                                              return 1137;
2542                                                            }
2543                                                        }
2544                                                    }
2545                                                }
2546                                            }
2547                                        }
2548                                    }
2549                                }
2550                              else
2551                                {
2552                                  if (((word >> 21) & 0x1) == 0)
2553                                    {
2554                                      if (((word >> 23) & 0x1) == 0)
2555                                        {
2556                                          if (((word >> 22) & 0x1) == 0)
2557                                            {
2558                                              if (((word >> 31) & 0x1) == 0)
2559                                                {
2560                                                  if (((word >> 30) & 0x1) == 0)
2561                                                    {
2562                                                      /* 33222222222211111111110000000000
2563                                                         10987654321098765432109876543210
2564                                                         00111000000xxxxxxxxx10xxxxxxxxxx
2565                                                         sttrb.  */
2566                                                      return 913;
2567                                                    }
2568                                                  else
2569                                                    {
2570                                                      /* 33222222222211111111110000000000
2571                                                         10987654321098765432109876543210
2572                                                         01111000000xxxxxxxxx10xxxxxxxxxx
2573                                                         sttrh.  */
2574                                                      return 916;
2575                                                    }
2576                                                }
2577                                              else
2578                                                {
2579                                                  /* 33222222222211111111110000000000
2580                                                     10987654321098765432109876543210
2581                                                     1x111000000xxxxxxxxx10xxxxxxxxxx
2582                                                     sttr.  */
2583                                                  return 919;
2584                                                }
2585                                            }
2586                                          else
2587                                            {
2588                                              if (((word >> 31) & 0x1) == 0)
2589                                                {
2590                                                  if (((word >> 30) & 0x1) == 0)
2591                                                    {
2592                                                      /* 33222222222211111111110000000000
2593                                                         10987654321098765432109876543210
2594                                                         00111000010xxxxxxxxx10xxxxxxxxxx
2595                                                         ldtrb.  */
2596                                                      return 914;
2597                                                    }
2598                                                  else
2599                                                    {
2600                                                      /* 33222222222211111111110000000000
2601                                                         10987654321098765432109876543210
2602                                                         01111000010xxxxxxxxx10xxxxxxxxxx
2603                                                         ldtrh.  */
2604                                                      return 917;
2605                                                    }
2606                                                }
2607                                              else
2608                                                {
2609                                                  /* 33222222222211111111110000000000
2610                                                     10987654321098765432109876543210
2611                                                     1x111000010xxxxxxxxx10xxxxxxxxxx
2612                                                     ldtr.  */
2613                                                  return 920;
2614                                                }
2615                                            }
2616                                        }
2617                                      else
2618                                        {
2619                                          if (((word >> 30) & 0x1) == 0)
2620                                            {
2621                                              if (((word >> 31) & 0x1) == 0)
2622                                                {
2623                                                  /* 33222222222211111111110000000000
2624                                                     10987654321098765432109876543210
2625                                                     001110001x0xxxxxxxxx10xxxxxxxxxx
2626                                                     ldtrsb.  */
2627                                                  return 915;
2628                                                }
2629                                              else
2630                                                {
2631                                                  /* 33222222222211111111110000000000
2632                                                     10987654321098765432109876543210
2633                                                     101110001x0xxxxxxxxx10xxxxxxxxxx
2634                                                     ldtrsw.  */
2635                                                  return 921;
2636                                                }
2637                                            }
2638                                          else
2639                                            {
2640                                              /* 33222222222211111111110000000000
2641                                                 10987654321098765432109876543210
2642                                                 x11110001x0xxxxxxxxx10xxxxxxxxxx
2643                                                 ldtrsh.  */
2644                                              return 918;
2645                                            }
2646                                        }
2647                                    }
2648                                  else
2649                                    {
2650                                      if (((word >> 23) & 0x1) == 0)
2651                                        {
2652                                          if (((word >> 22) & 0x1) == 0)
2653                                            {
2654                                              if (((word >> 31) & 0x1) == 0)
2655                                                {
2656                                                  if (((word >> 30) & 0x1) == 0)
2657                                                    {
2658                                                      /* 33222222222211111111110000000000
2659                                                         10987654321098765432109876543210
2660                                                         00111000001xxxxxxxxx10xxxxxxxxxx
2661                                                         strb.  */
2662                                                      return 901;
2663                                                    }
2664                                                  else
2665                                                    {
2666                                                      /* 33222222222211111111110000000000
2667                                                         10987654321098765432109876543210
2668                                                         01111000001xxxxxxxxx10xxxxxxxxxx
2669                                                         strh.  */
2670                                                      return 906;
2671                                                    }
2672                                                }
2673                                              else
2674                                                {
2675                                                  /* 33222222222211111111110000000000
2676                                                     10987654321098765432109876543210
2677                                                     1x111000001xxxxxxxxx10xxxxxxxxxx
2678                                                     str.  */
2679                                                  return 909;
2680                                                }
2681                                            }
2682                                          else
2683                                            {
2684                                              if (((word >> 31) & 0x1) == 0)
2685                                                {
2686                                                  if (((word >> 30) & 0x1) == 0)
2687                                                    {
2688                                                      /* 33222222222211111111110000000000
2689                                                         10987654321098765432109876543210
2690                                                         00111000011xxxxxxxxx10xxxxxxxxxx
2691                                                         ldrb.  */
2692                                                      return 902;
2693                                                    }
2694                                                  else
2695                                                    {
2696                                                      /* 33222222222211111111110000000000
2697                                                         10987654321098765432109876543210
2698                                                         01111000011xxxxxxxxx10xxxxxxxxxx
2699                                                         ldrh.  */
2700                                                      return 907;
2701                                                    }
2702                                                }
2703                                              else
2704                                                {
2705                                                  /* 33222222222211111111110000000000
2706                                                     10987654321098765432109876543210
2707                                                     1x111000011xxxxxxxxx10xxxxxxxxxx
2708                                                     ldr.  */
2709                                                  return 910;
2710                                                }
2711                                            }
2712                                        }
2713                                      else
2714                                        {
2715                                          if (((word >> 30) & 0x1) == 0)
2716                                            {
2717                                              if (((word >> 31) & 0x1) == 0)
2718                                                {
2719                                                  /* 33222222222211111111110000000000
2720                                                     10987654321098765432109876543210
2721                                                     001110001x1xxxxxxxxx10xxxxxxxxxx
2722                                                     ldrsb.  */
2723                                                  return 903;
2724                                                }
2725                                              else
2726                                                {
2727                                                  /* 33222222222211111111110000000000
2728                                                     10987654321098765432109876543210
2729                                                     101110001x1xxxxxxxxx10xxxxxxxxxx
2730                                                     ldrsw.  */
2731                                                  return 911;
2732                                                }
2733                                            }
2734                                          else
2735                                            {
2736                                              if (((word >> 31) & 0x1) == 0)
2737                                                {
2738                                                  /* 33222222222211111111110000000000
2739                                                     10987654321098765432109876543210
2740                                                     011110001x1xxxxxxxxx10xxxxxxxxxx
2741                                                     ldrsh.  */
2742                                                  return 908;
2743                                                }
2744                                              else
2745                                                {
2746                                                  /* 33222222222211111111110000000000
2747                                                     10987654321098765432109876543210
2748                                                     111110001x1xxxxxxxxx10xxxxxxxxxx
2749                                                     prfm.  */
2750                                                  return 912;
2751                                                }
2752                                            }
2753                                        }
2754                                    }
2755                                }
2756                            }
2757                          else
2758                            {
2759                              if (((word >> 21) & 0x1) == 0)
2760                                {
2761                                  if (((word >> 23) & 0x1) == 0)
2762                                    {
2763                                      if (((word >> 22) & 0x1) == 0)
2764                                        {
2765                                          if (((word >> 31) & 0x1) == 0)
2766                                            {
2767                                              if (((word >> 30) & 0x1) == 0)
2768                                                {
2769                                                  /* 33222222222211111111110000000000
2770                                                     10987654321098765432109876543210
2771                                                     00111000000xxxxxxxxxx1xxxxxxxxxx
2772                                                     strb.  */
2773                                                  return 870;
2774                                                }
2775                                              else
2776                                                {
2777                                                  /* 33222222222211111111110000000000
2778                                                     10987654321098765432109876543210
2779                                                     01111000000xxxxxxxxxx1xxxxxxxxxx
2780                                                     strh.  */
2781                                                  return 875;
2782                                                }
2783                                            }
2784                                          else
2785                                            {
2786                                              /* 33222222222211111111110000000000
2787                                                 10987654321098765432109876543210
2788                                                 1x111000000xxxxxxxxxx1xxxxxxxxxx
2789                                                 str.  */
2790                                              return 878;
2791                                            }
2792                                        }
2793                                      else
2794                                        {
2795                                          if (((word >> 31) & 0x1) == 0)
2796                                            {
2797                                              if (((word >> 30) & 0x1) == 0)
2798                                                {
2799                                                  /* 33222222222211111111110000000000
2800                                                     10987654321098765432109876543210
2801                                                     00111000010xxxxxxxxxx1xxxxxxxxxx
2802                                                     ldrb.  */
2803                                                  return 871;
2804                                                }
2805                                              else
2806                                                {
2807                                                  /* 33222222222211111111110000000000
2808                                                     10987654321098765432109876543210
2809                                                     01111000010xxxxxxxxxx1xxxxxxxxxx
2810                                                     ldrh.  */
2811                                                  return 876;
2812                                                }
2813                                            }
2814                                          else
2815                                            {
2816                                              /* 33222222222211111111110000000000
2817                                                 10987654321098765432109876543210
2818                                                 1x111000010xxxxxxxxxx1xxxxxxxxxx
2819                                                 ldr.  */
2820                                              return 879;
2821                                            }
2822                                        }
2823                                    }
2824                                  else
2825                                    {
2826                                      if (((word >> 30) & 0x1) == 0)
2827                                        {
2828                                          if (((word >> 31) & 0x1) == 0)
2829                                            {
2830                                              /* 33222222222211111111110000000000
2831                                                 10987654321098765432109876543210
2832                                                 001110001x0xxxxxxxxxx1xxxxxxxxxx
2833                                                 ldrsb.  */
2834                                              return 872;
2835                                            }
2836                                          else
2837                                            {
2838                                              /* 33222222222211111111110000000000
2839                                                 10987654321098765432109876543210
2840                                                 101110001x0xxxxxxxxxx1xxxxxxxxxx
2841                                                 ldrsw.  */
2842                                              return 880;
2843                                            }
2844                                        }
2845                                      else
2846                                        {
2847                                          /* 33222222222211111111110000000000
2848                                             10987654321098765432109876543210
2849                                             x11110001x0xxxxxxxxxx1xxxxxxxxxx
2850                                             ldrsh.  */
2851                                          return 877;
2852                                        }
2853                                    }
2854                                }
2855                              else
2856                                {
2857                                  if (((word >> 23) & 0x1) == 0)
2858                                    {
2859                                      /* 33222222222211111111110000000000
2860                                         10987654321098765432109876543210
2861                                         xx1110000x1xxxxxxxxxx1xxxxxxxxxx
2862                                         ldraa.  */
2863                                      return 935;
2864                                    }
2865                                  else
2866                                    {
2867                                      /* 33222222222211111111110000000000
2868                                         10987654321098765432109876543210
2869                                         xx1110001x1xxxxxxxxxx1xxxxxxxxxx
2870                                         ldrab.  */
2871                                      return 936;
2872                                    }
2873                                }
2874                            }
2875                        }
2876                    }
2877                  else
2878                    {
2879                      if (((word >> 23) & 0x1) == 0)
2880                        {
2881                          if (((word >> 22) & 0x1) == 0)
2882                            {
2883                              if (((word >> 29) & 0x1) == 0)
2884                                {
2885                                  if (((word >> 10) & 0x1) == 0)
2886                                    {
2887                                      if (((word >> 11) & 0x1) == 0)
2888                                        {
2889                                          if (((word >> 21) & 0x1) == 0)
2890                                            {
2891                                              if (((word >> 30) & 0x1) == 0)
2892                                                {
2893                                                  if (((word >> 31) & 0x1) == 0)
2894                                                    {
2895                                                      /* 33222222222211111111110000000000
2896                                                         10987654321098765432109876543210
2897                                                         00011001000xxxxxxxxx00xxxxxxxxxx
2898                                                         stlurb.  */
2899                                                      return 2454;
2900                                                    }
2901                                                  else
2902                                                    {
2903                                                      /* 33222222222211111111110000000000
2904                                                         10987654321098765432109876543210
2905                                                         10011001000xxxxxxxxx00xxxxxxxxxx
2906                                                         stlur.  */
2907                                                      return 2462;
2908                                                    }
2909                                                }
2910                                              else
2911                                                {
2912                                                  if (((word >> 31) & 0x1) == 0)
2913                                                    {
2914                                                      /* 33222222222211111111110000000000
2915                                                         10987654321098765432109876543210
2916                                                         01011001000xxxxxxxxx00xxxxxxxxxx
2917                                                         stlurh.  */
2918                                                      return 2458;
2919                                                    }
2920                                                  else
2921                                                    {
2922                                                      /* 33222222222211111111110000000000
2923                                                         10987654321098765432109876543210
2924                                                         11011001000xxxxxxxxx00xxxxxxxxxx
2925                                                         stlur.  */
2926                                                      return 2465;
2927                                                    }
2928                                                }
2929                                            }
2930                                          else
2931                                            {
2932                                              /* 33222222222211111111110000000000
2933                                                 10987654321098765432109876543210
2934                                                 xx011001001xxxxxxxxx00xxxxxxxxxx
2935                                                 stzgm.  */
2936                                              return 964;
2937                                            }
2938                                        }
2939                                      else
2940                                        {
2941                                          /* 33222222222211111111110000000000
2942                                             10987654321098765432109876543210
2943                                             xx01100100xxxxxxxxxx10xxxxxxxxxx
2944                                             stg.  */
2945                                          return 881;
2946                                        }
2947                                    }
2948                                  else
2949                                    {
2950                                      if (((word >> 21) & 0x1) == 0)
2951                                        {
2952                                          if (((word >> 12) & 0x1) == 0)
2953                                            {
2954                                              if (((word >> 13) & 0x1) == 0)
2955                                                {
2956                                                  if (((word >> 14) & 0x1) == 0)
2957                                                    {
2958                                                      if (((word >> 15) & 0x1) == 0)
2959                                                        {
2960                                                          /* 33222222222211111111110000000000
2961                                                             10987654321098765432109876543210
2962                                                             xx011001000xxxxx0000x1xxxxxxxxxx
2963                                                             cpyfp.  */
2964                                                          return 2514;
2965                                                        }
2966                                                      else
2967                                                        {
2968                                                          /* 33222222222211111111110000000000
2969                                                             10987654321098765432109876543210
2970                                                             xx011001000xxxxx1000x1xxxxxxxxxx
2971                                                             cpyfprn.  */
2972                                                          return 2520;
2973                                                        }
2974                                                    }
2975                                                  else
2976                                                    {
2977                                                      if (((word >> 15) & 0x1) == 0)
2978                                                        {
2979                                                          /* 33222222222211111111110000000000
2980                                                             10987654321098765432109876543210
2981                                                             xx011001000xxxxx0100x1xxxxxxxxxx
2982                                                             cpyfpwn.  */
2983                                                          return 2517;
2984                                                        }
2985                                                      else
2986                                                        {
2987                                                          /* 33222222222211111111110000000000
2988                                                             10987654321098765432109876543210
2989                                                             xx011001000xxxxx1100x1xxxxxxxxxx
2990                                                             cpyfpn.  */
2991                                                          return 2523;
2992                                                        }
2993                                                    }
2994                                                }
2995                                              else
2996                                                {
2997                                                  if (((word >> 14) & 0x1) == 0)
2998                                                    {
2999                                                      if (((word >> 15) & 0x1) == 0)
3000                                                        {
3001                                                          /* 33222222222211111111110000000000
3002                                                             10987654321098765432109876543210
3003                                                             xx011001000xxxxx0010x1xxxxxxxxxx
3004                                                             cpyfprt.  */
3005                                                          return 2538;
3006                                                        }
3007                                                      else
3008                                                        {
3009                                                          /* 33222222222211111111110000000000
3010                                                             10987654321098765432109876543210
3011                                                             xx011001000xxxxx1010x1xxxxxxxxxx
3012                                                             cpyfprtrn.  */
3013                                                          return 2544;
3014                                                        }
3015                                                    }
3016                                                  else
3017                                                    {
3018                                                      if (((word >> 15) & 0x1) == 0)
3019                                                        {
3020                                                          /* 33222222222211111111110000000000
3021                                                             10987654321098765432109876543210
3022                                                             xx011001000xxxxx0110x1xxxxxxxxxx
3023                                                             cpyfprtwn.  */
3024                                                          return 2541;
3025                                                        }
3026                                                      else
3027                                                        {
3028                                                          /* 33222222222211111111110000000000
3029                                                             10987654321098765432109876543210
3030                                                             xx011001000xxxxx1110x1xxxxxxxxxx
3031                                                             cpyfprtn.  */
3032                                                          return 2547;
3033                                                        }
3034                                                    }
3035                                                }
3036                                            }
3037                                          else
3038                                            {
3039                                              if (((word >> 13) & 0x1) == 0)
3040                                                {
3041                                                  if (((word >> 14) & 0x1) == 0)
3042                                                    {
3043                                                      if (((word >> 15) & 0x1) == 0)
3044                                                        {
3045                                                          /* 33222222222211111111110000000000
3046                                                             10987654321098765432109876543210
3047                                                             xx011001000xxxxx0001x1xxxxxxxxxx
3048                                                             cpyfpwt.  */
3049                                                          return 2526;
3050                                                        }
3051                                                      else
3052                                                        {
3053                                                          /* 33222222222211111111110000000000
3054                                                             10987654321098765432109876543210
3055                                                             xx011001000xxxxx1001x1xxxxxxxxxx
3056                                                             cpyfpwtrn.  */
3057                                                          return 2532;
3058                                                        }
3059                                                    }
3060                                                  else
3061                                                    {
3062                                                      if (((word >> 15) & 0x1) == 0)
3063                                                        {
3064                                                          /* 33222222222211111111110000000000
3065                                                             10987654321098765432109876543210
3066                                                             xx011001000xxxxx0101x1xxxxxxxxxx
3067                                                             cpyfpwtwn.  */
3068                                                          return 2529;
3069                                                        }
3070                                                      else
3071                                                        {
3072                                                          /* 33222222222211111111110000000000
3073                                                             10987654321098765432109876543210
3074                                                             xx011001000xxxxx1101x1xxxxxxxxxx
3075                                                             cpyfpwtn.  */
3076                                                          return 2535;
3077                                                        }
3078                                                    }
3079                                                }
3080                                              else
3081                                                {
3082                                                  if (((word >> 14) & 0x1) == 0)
3083                                                    {
3084                                                      if (((word >> 15) & 0x1) == 0)
3085                                                        {
3086                                                          /* 33222222222211111111110000000000
3087                                                             10987654321098765432109876543210
3088                                                             xx011001000xxxxx0011x1xxxxxxxxxx
3089                                                             cpyfpt.  */
3090                                                          return 2550;
3091                                                        }
3092                                                      else
3093                                                        {
3094                                                          /* 33222222222211111111110000000000
3095                                                             10987654321098765432109876543210
3096                                                             xx011001000xxxxx1011x1xxxxxxxxxx
3097                                                             cpyfptrn.  */
3098                                                          return 2556;
3099                                                        }
3100                                                    }
3101                                                  else
3102                                                    {
3103                                                      if (((word >> 15) & 0x1) == 0)
3104                                                        {
3105                                                          /* 33222222222211111111110000000000
3106                                                             10987654321098765432109876543210
3107                                                             xx011001000xxxxx0111x1xxxxxxxxxx
3108                                                             cpyfptwn.  */
3109                                                          return 2553;
3110                                                        }
3111                                                      else
3112                                                        {
3113                                                          /* 33222222222211111111110000000000
3114                                                             10987654321098765432109876543210
3115                                                             xx011001000xxxxx1111x1xxxxxxxxxx
3116                                                             cpyfptn.  */
3117                                                          return 2559;
3118                                                        }
3119                                                    }
3120                                                }
3121                                            }
3122                                        }
3123                                      else
3124                                        {
3125                                          /* 33222222222211111111110000000000
3126                                             10987654321098765432109876543210
3127                                             xx011001001xxxxxxxxxx1xxxxxxxxxx
3128                                             stg.  */
3129                                          return 885;
3130                                        }
3131                                    }
3132                                }
3133                              else
3134                                {
3135                                  if (((word >> 31) & 0x1) == 0)
3136                                    {
3137                                      if (((word >> 30) & 0x1) == 0)
3138                                        {
3139                                          /* 33222222222211111111110000000000
3140                                             10987654321098765432109876543210
3141                                             0011100100xxxxxxxxxxxxxxxxxxxxxx
3142                                             strb.  */
3143                                          return 889;
3144                                        }
3145                                      else
3146                                        {
3147                                          /* 33222222222211111111110000000000
3148                                             10987654321098765432109876543210
3149                                             0111100100xxxxxxxxxxxxxxxxxxxxxx
3150                                             strh.  */
3151                                          return 894;
3152                                        }
3153                                    }
3154                                  else
3155                                    {
3156                                      /* 33222222222211111111110000000000
3157                                         10987654321098765432109876543210
3158                                         1x11100100xxxxxxxxxxxxxxxxxxxxxx
3159                                         str.  */
3160                                      return 897;
3161                                    }
3162                                }
3163                            }
3164                          else
3165                            {
3166                              if (((word >> 29) & 0x1) == 0)
3167                                {
3168                                  if (((word >> 10) & 0x1) == 0)
3169                                    {
3170                                      if (((word >> 11) & 0x1) == 0)
3171                                        {
3172                                          if (((word >> 21) & 0x1) == 0)
3173                                            {
3174                                              if (((word >> 30) & 0x1) == 0)
3175                                                {
3176                                                  if (((word >> 31) & 0x1) == 0)
3177                                                    {
3178                                                      /* 33222222222211111111110000000000
3179                                                         10987654321098765432109876543210
3180                                                         00011001010xxxxxxxxx00xxxxxxxxxx
3181                                                         ldapurb.  */
3182                                                      return 2455;
3183                                                    }
3184                                                  else
3185                                                    {
3186                                                      /* 33222222222211111111110000000000
3187                                                         10987654321098765432109876543210
3188                                                         10011001010xxxxxxxxx00xxxxxxxxxx
3189                                                         ldapur.  */
3190                                                      return 2463;
3191                                                    }
3192                                                }
3193                                              else
3194                                                {
3195                                                  if (((word >> 31) & 0x1) == 0)
3196                                                    {
3197                                                      /* 33222222222211111111110000000000
3198                                                         10987654321098765432109876543210
3199                                                         01011001010xxxxxxxxx00xxxxxxxxxx
3200                                                         ldapurh.  */
3201                                                      return 2459;
3202                                                    }
3203                                                  else
3204                                                    {
3205                                                      /* 33222222222211111111110000000000
3206                                                         10987654321098765432109876543210
3207                                                         11011001010xxxxxxxxx00xxxxxxxxxx
3208                                                         ldapur.  */
3209                                                      return 2466;
3210                                                    }
3211                                                }
3212                                            }
3213                                          else
3214                                            {
3215                                              /* 33222222222211111111110000000000
3216                                                 10987654321098765432109876543210
3217                                                 xx011001011xxxxxxxxx00xxxxxxxxxx
3218                                                 ldg.  */
3219                                              return 934;
3220                                            }
3221                                        }
3222                                      else
3223                                        {
3224                                          /* 33222222222211111111110000000000
3225                                             10987654321098765432109876543210
3226                                             xx01100101xxxxxxxxxx10xxxxxxxxxx
3227                                             stzg.  */
3228                                          return 882;
3229                                        }
3230                                    }
3231                                  else
3232                                    {
3233                                      if (((word >> 21) & 0x1) == 0)
3234                                        {
3235                                          if (((word >> 12) & 0x1) == 0)
3236                                            {
3237                                              if (((word >> 13) & 0x1) == 0)
3238                                                {
3239                                                  if (((word >> 14) & 0x1) == 0)
3240                                                    {
3241                                                      if (((word >> 15) & 0x1) == 0)
3242                                                        {
3243                                                          /* 33222222222211111111110000000000
3244                                                             10987654321098765432109876543210
3245                                                             xx011001010xxxxx0000x1xxxxxxxxxx
3246                                                             cpyfm.  */
3247                                                          return 2515;
3248                                                        }
3249                                                      else
3250                                                        {
3251                                                          /* 33222222222211111111110000000000
3252                                                             10987654321098765432109876543210
3253                                                             xx011001010xxxxx1000x1xxxxxxxxxx
3254                                                             cpyfmrn.  */
3255                                                          return 2521;
3256                                                        }
3257                                                    }
3258                                                  else
3259                                                    {
3260                                                      if (((word >> 15) & 0x1) == 0)
3261                                                        {
3262                                                          /* 33222222222211111111110000000000
3263                                                             10987654321098765432109876543210
3264                                                             xx011001010xxxxx0100x1xxxxxxxxxx
3265                                                             cpyfmwn.  */
3266                                                          return 2518;
3267                                                        }
3268                                                      else
3269                                                        {
3270                                                          /* 33222222222211111111110000000000
3271                                                             10987654321098765432109876543210
3272                                                             xx011001010xxxxx1100x1xxxxxxxxxx
3273                                                             cpyfmn.  */
3274                                                          return 2524;
3275                                                        }
3276                                                    }
3277                                                }
3278                                              else
3279                                                {
3280                                                  if (((word >> 14) & 0x1) == 0)
3281                                                    {
3282                                                      if (((word >> 15) & 0x1) == 0)
3283                                                        {
3284                                                          /* 33222222222211111111110000000000
3285                                                             10987654321098765432109876543210
3286                                                             xx011001010xxxxx0010x1xxxxxxxxxx
3287                                                             cpyfmrt.  */
3288                                                          return 2539;
3289                                                        }
3290                                                      else
3291                                                        {
3292                                                          /* 33222222222211111111110000000000
3293                                                             10987654321098765432109876543210
3294                                                             xx011001010xxxxx1010x1xxxxxxxxxx
3295                                                             cpyfmrtrn.  */
3296                                                          return 2545;
3297                                                        }
3298                                                    }
3299                                                  else
3300                                                    {
3301                                                      if (((word >> 15) & 0x1) == 0)
3302                                                        {
3303                                                          /* 33222222222211111111110000000000
3304                                                             10987654321098765432109876543210
3305                                                             xx011001010xxxxx0110x1xxxxxxxxxx
3306                                                             cpyfmrtwn.  */
3307                                                          return 2542;
3308                                                        }
3309                                                      else
3310                                                        {
3311                                                          /* 33222222222211111111110000000000
3312                                                             10987654321098765432109876543210
3313                                                             xx011001010xxxxx1110x1xxxxxxxxxx
3314                                                             cpyfmrtn.  */
3315                                                          return 2548;
3316                                                        }
3317                                                    }
3318                                                }
3319                                            }
3320                                          else
3321                                            {
3322                                              if (((word >> 13) & 0x1) == 0)
3323                                                {
3324                                                  if (((word >> 14) & 0x1) == 0)
3325                                                    {
3326                                                      if (((word >> 15) & 0x1) == 0)
3327                                                        {
3328                                                          /* 33222222222211111111110000000000
3329                                                             10987654321098765432109876543210
3330                                                             xx011001010xxxxx0001x1xxxxxxxxxx
3331                                                             cpyfmwt.  */
3332                                                          return 2527;
3333                                                        }
3334                                                      else
3335                                                        {
3336                                                          /* 33222222222211111111110000000000
3337                                                             10987654321098765432109876543210
3338                                                             xx011001010xxxxx1001x1xxxxxxxxxx
3339                                                             cpyfmwtrn.  */
3340                                                          return 2533;
3341                                                        }
3342                                                    }
3343                                                  else
3344                                                    {
3345                                                      if (((word >> 15) & 0x1) == 0)
3346                                                        {
3347                                                          /* 33222222222211111111110000000000
3348                                                             10987654321098765432109876543210
3349                                                             xx011001010xxxxx0101x1xxxxxxxxxx
3350                                                             cpyfmwtwn.  */
3351                                                          return 2530;
3352                                                        }
3353                                                      else
3354                                                        {
3355                                                          /* 33222222222211111111110000000000
3356                                                             10987654321098765432109876543210
3357                                                             xx011001010xxxxx1101x1xxxxxxxxxx
3358                                                             cpyfmwtn.  */
3359                                                          return 2536;
3360                                                        }
3361                                                    }
3362                                                }
3363                                              else
3364                                                {
3365                                                  if (((word >> 14) & 0x1) == 0)
3366                                                    {
3367                                                      if (((word >> 15) & 0x1) == 0)
3368                                                        {
3369                                                          /* 33222222222211111111110000000000
3370                                                             10987654321098765432109876543210
3371                                                             xx011001010xxxxx0011x1xxxxxxxxxx
3372                                                             cpyfmt.  */
3373                                                          return 2551;
3374                                                        }
3375                                                      else
3376                                                        {
3377                                                          /* 33222222222211111111110000000000
3378                                                             10987654321098765432109876543210
3379                                                             xx011001010xxxxx1011x1xxxxxxxxxx
3380                                                             cpyfmtrn.  */
3381                                                          return 2557;
3382                                                        }
3383                                                    }
3384                                                  else
3385                                                    {
3386                                                      if (((word >> 15) & 0x1) == 0)
3387                                                        {
3388                                                          /* 33222222222211111111110000000000
3389                                                             10987654321098765432109876543210
3390                                                             xx011001010xxxxx0111x1xxxxxxxxxx
3391                                                             cpyfmtwn.  */
3392                                                          return 2554;
3393                                                        }
3394                                                      else
3395                                                        {
3396                                                          /* 33222222222211111111110000000000
3397                                                             10987654321098765432109876543210
3398                                                             xx011001010xxxxx1111x1xxxxxxxxxx
3399                                                             cpyfmtn.  */
3400                                                          return 2560;
3401                                                        }
3402                                                    }
3403                                                }
3404                                            }
3405                                        }
3406                                      else
3407                                        {
3408                                          /* 33222222222211111111110000000000
3409                                             10987654321098765432109876543210
3410                                             xx011001011xxxxxxxxxx1xxxxxxxxxx
3411                                             stzg.  */
3412                                          return 886;
3413                                        }
3414                                    }
3415                                }
3416                              else
3417                                {
3418                                  if (((word >> 31) & 0x1) == 0)
3419                                    {
3420                                      if (((word >> 30) & 0x1) == 0)
3421                                        {
3422                                          /* 33222222222211111111110000000000
3423                                             10987654321098765432109876543210
3424                                             0011100101xxxxxxxxxxxxxxxxxxxxxx
3425                                             ldrb.  */
3426                                          return 890;
3427                                        }
3428                                      else
3429                                        {
3430                                          /* 33222222222211111111110000000000
3431                                             10987654321098765432109876543210
3432                                             0111100101xxxxxxxxxxxxxxxxxxxxxx
3433                                             ldrh.  */
3434                                          return 895;
3435                                        }
3436                                    }
3437                                  else
3438                                    {
3439                                      /* 33222222222211111111110000000000
3440                                         10987654321098765432109876543210
3441                                         1x11100101xxxxxxxxxxxxxxxxxxxxxx
3442                                         ldr.  */
3443                                      return 898;
3444                                    }
3445                                }
3446                            }
3447                        }
3448                      else
3449                        {
3450                          if (((word >> 29) & 0x1) == 0)
3451                            {
3452                              if (((word >> 10) & 0x1) == 0)
3453                                {
3454                                  if (((word >> 11) & 0x1) == 0)
3455                                    {
3456                                      if (((word >> 21) & 0x1) == 0)
3457                                        {
3458                                          if (((word >> 22) & 0x1) == 0)
3459                                            {
3460                                              if (((word >> 30) & 0x1) == 0)
3461                                                {
3462                                                  if (((word >> 31) & 0x1) == 0)
3463                                                    {
3464                                                      /* 33222222222211111111110000000000
3465                                                         10987654321098765432109876543210
3466                                                         00011001100xxxxxxxxx00xxxxxxxxxx
3467                                                         ldapursb.  */
3468                                                      return 2457;
3469                                                    }
3470                                                  else
3471                                                    {
3472                                                      /* 33222222222211111111110000000000
3473                                                         10987654321098765432109876543210
3474                                                         10011001100xxxxxxxxx00xxxxxxxxxx
3475                                                         ldapursw.  */
3476                                                      return 2464;
3477                                                    }
3478                                                }
3479                                              else
3480                                                {
3481                                                  /* 33222222222211111111110000000000
3482                                                     10987654321098765432109876543210
3483                                                     x1011001100xxxxxxxxx00xxxxxxxxxx
3484                                                     ldapursh.  */
3485                                                  return 2461;
3486                                                }
3487                                            }
3488                                          else
3489                                            {
3490                                              if (((word >> 30) & 0x1) == 0)
3491                                                {
3492                                                  /* 33222222222211111111110000000000
3493                                                     10987654321098765432109876543210
3494                                                     x0011001110xxxxxxxxx00xxxxxxxxxx
3495                                                     ldapursb.  */
3496                                                  return 2456;
3497                                                }
3498                                              else
3499                                                {
3500                                                  /* 33222222222211111111110000000000
3501                                                     10987654321098765432109876543210
3502                                                     x1011001110xxxxxxxxx00xxxxxxxxxx
3503                                                     ldapursh.  */
3504                                                  return 2460;
3505                                                }
3506                                            }
3507                                        }
3508                                      else
3509                                        {
3510                                          if (((word >> 22) & 0x1) == 0)
3511                                            {
3512                                              /* 33222222222211111111110000000000
3513                                                 10987654321098765432109876543210
3514                                                 xx011001101xxxxxxxxx00xxxxxxxxxx
3515                                                 stgm.  */
3516                                              return 963;
3517                                            }
3518                                          else
3519                                            {
3520                                              /* 33222222222211111111110000000000
3521                                                 10987654321098765432109876543210
3522                                                 xx011001111xxxxxxxxx00xxxxxxxxxx
3523                                                 ldgm.  */
3524                                              return 962;
3525                                            }
3526                                        }
3527                                    }
3528                                  else
3529                                    {
3530                                      if (((word >> 22) & 0x1) == 0)
3531                                        {
3532                                          /* 33222222222211111111110000000000
3533                                             10987654321098765432109876543210
3534                                             xx01100110xxxxxxxxxx10xxxxxxxxxx
3535                                             st2g.  */
3536                                          return 883;
3537                                        }
3538                                      else
3539                                        {
3540                                          /* 33222222222211111111110000000000
3541                                             10987654321098765432109876543210
3542                                             xx01100111xxxxxxxxxx10xxxxxxxxxx
3543                                             stz2g.  */
3544                                          return 884;
3545                                        }
3546                                    }
3547                                }
3548                              else
3549                                {
3550                                  if (((word >> 21) & 0x1) == 0)
3551                                    {
3552                                      if (((word >> 12) & 0x1) == 0)
3553                                        {
3554                                          if (((word >> 13) & 0x1) == 0)
3555                                            {
3556                                              if (((word >> 14) & 0x1) == 0)
3557                                                {
3558                                                  if (((word >> 15) & 0x1) == 0)
3559                                                    {
3560                                                      if (((word >> 22) & 0x1) == 0)
3561                                                        {
3562                                                          /* 33222222222211111111110000000000
3563                                                             10987654321098765432109876543210
3564                                                             xx011001100xxxxx0000x1xxxxxxxxxx
3565                                                             cpyfe.  */
3566                                                          return 2516;
3567                                                        }
3568                                                      else
3569                                                        {
3570                                                          /* 33222222222211111111110000000000
3571                                                             10987654321098765432109876543210
3572                                                             xx011001110xxxxx0000x1xxxxxxxxxx
3573                                                             setp.  */
3574                                                          return 2610;
3575                                                        }
3576                                                    }
3577                                                  else
3578                                                    {
3579                                                      if (((word >> 22) & 0x1) == 0)
3580                                                        {
3581                                                          /* 33222222222211111111110000000000
3582                                                             10987654321098765432109876543210
3583                                                             xx011001100xxxxx1000x1xxxxxxxxxx
3584                                                             cpyfern.  */
3585                                                          return 2522;
3586                                                        }
3587                                                      else
3588                                                        {
3589                                                          /* 33222222222211111111110000000000
3590                                                             10987654321098765432109876543210
3591                                                             xx011001110xxxxx1000x1xxxxxxxxxx
3592                                                             sete.  */
3593                                                          return 2612;
3594                                                        }
3595                                                    }
3596                                                }
3597                                              else
3598                                                {
3599                                                  if (((word >> 15) & 0x1) == 0)
3600                                                    {
3601                                                      if (((word >> 22) & 0x1) == 0)
3602                                                        {
3603                                                          /* 33222222222211111111110000000000
3604                                                             10987654321098765432109876543210
3605                                                             xx011001100xxxxx0100x1xxxxxxxxxx
3606                                                             cpyfewn.  */
3607                                                          return 2519;
3608                                                        }
3609                                                      else
3610                                                        {
3611                                                          /* 33222222222211111111110000000000
3612                                                             10987654321098765432109876543210
3613                                                             xx011001110xxxxx0100x1xxxxxxxxxx
3614                                                             setm.  */
3615                                                          return 2611;
3616                                                        }
3617                                                    }
3618                                                  else
3619                                                    {
3620                                                      /* 33222222222211111111110000000000
3621                                                         10987654321098765432109876543210
3622                                                         xx0110011x0xxxxx1100x1xxxxxxxxxx
3623                                                         cpyfen.  */
3624                                                      return 2525;
3625                                                    }
3626                                                }
3627                                            }
3628                                          else
3629                                            {
3630                                              if (((word >> 14) & 0x1) == 0)
3631                                                {
3632                                                  if (((word >> 15) & 0x1) == 0)
3633                                                    {
3634                                                      if (((word >> 22) & 0x1) == 0)
3635                                                        {
3636                                                          /* 33222222222211111111110000000000
3637                                                             10987654321098765432109876543210
3638                                                             xx011001100xxxxx0010x1xxxxxxxxxx
3639                                                             cpyfert.  */
3640                                                          return 2540;
3641                                                        }
3642                                                      else
3643                                                        {
3644                                                          /* 33222222222211111111110000000000
3645                                                             10987654321098765432109876543210
3646                                                             xx011001110xxxxx0010x1xxxxxxxxxx
3647                                                             setpn.  */
3648                                                          return 2616;
3649                                                        }
3650                                                    }
3651                                                  else
3652                                                    {
3653                                                      if (((word >> 22) & 0x1) == 0)
3654                                                        {
3655                                                          /* 33222222222211111111110000000000
3656                                                             10987654321098765432109876543210
3657                                                             xx011001100xxxxx1010x1xxxxxxxxxx
3658                                                             cpyfertrn.  */
3659                                                          return 2546;
3660                                                        }
3661                                                      else
3662                                                        {
3663                                                          /* 33222222222211111111110000000000
3664                                                             10987654321098765432109876543210
3665                                                             xx011001110xxxxx1010x1xxxxxxxxxx
3666                                                             seten.  */
3667                                                          return 2618;
3668                                                        }
3669                                                    }
3670                                                }
3671                                              else
3672                                                {
3673                                                  if (((word >> 15) & 0x1) == 0)
3674                                                    {
3675                                                      if (((word >> 22) & 0x1) == 0)
3676                                                        {
3677                                                          /* 33222222222211111111110000000000
3678                                                             10987654321098765432109876543210
3679                                                             xx011001100xxxxx0110x1xxxxxxxxxx
3680                                                             cpyfertwn.  */
3681                                                          return 2543;
3682                                                        }
3683                                                      else
3684                                                        {
3685                                                          /* 33222222222211111111110000000000
3686                                                             10987654321098765432109876543210
3687                                                             xx011001110xxxxx0110x1xxxxxxxxxx
3688                                                             setmn.  */
3689                                                          return 2617;
3690                                                        }
3691                                                    }
3692                                                  else
3693                                                    {
3694                                                      /* 33222222222211111111110000000000
3695                                                         10987654321098765432109876543210
3696                                                         xx0110011x0xxxxx1110x1xxxxxxxxxx
3697                                                         cpyfertn.  */
3698                                                      return 2549;
3699                                                    }
3700                                                }
3701                                            }
3702                                        }
3703                                      else
3704                                        {
3705                                          if (((word >> 13) & 0x1) == 0)
3706                                            {
3707                                              if (((word >> 14) & 0x1) == 0)
3708                                                {
3709                                                  if (((word >> 15) & 0x1) == 0)
3710                                                    {
3711                                                      if (((word >> 22) & 0x1) == 0)
3712                                                        {
3713                                                          /* 33222222222211111111110000000000
3714                                                             10987654321098765432109876543210
3715                                                             xx011001100xxxxx0001x1xxxxxxxxxx
3716                                                             cpyfewt.  */
3717                                                          return 2528;
3718                                                        }
3719                                                      else
3720                                                        {
3721                                                          /* 33222222222211111111110000000000
3722                                                             10987654321098765432109876543210
3723                                                             xx011001110xxxxx0001x1xxxxxxxxxx
3724                                                             setpt.  */
3725                                                          return 2613;
3726                                                        }
3727                                                    }
3728                                                  else
3729                                                    {
3730                                                      if (((word >> 22) & 0x1) == 0)
3731                                                        {
3732                                                          /* 33222222222211111111110000000000
3733                                                             10987654321098765432109876543210
3734                                                             xx011001100xxxxx1001x1xxxxxxxxxx
3735                                                             cpyfewtrn.  */
3736                                                          return 2534;
3737                                                        }
3738                                                      else
3739                                                        {
3740                                                          /* 33222222222211111111110000000000
3741                                                             10987654321098765432109876543210
3742                                                             xx011001110xxxxx1001x1xxxxxxxxxx
3743                                                             setet.  */
3744                                                          return 2615;
3745                                                        }
3746                                                    }
3747                                                }
3748                                              else
3749                                                {
3750                                                  if (((word >> 15) & 0x1) == 0)
3751                                                    {
3752                                                      if (((word >> 22) & 0x1) == 0)
3753                                                        {
3754                                                          /* 33222222222211111111110000000000
3755                                                             10987654321098765432109876543210
3756                                                             xx011001100xxxxx0101x1xxxxxxxxxx
3757                                                             cpyfewtwn.  */
3758                                                          return 2531;
3759                                                        }
3760                                                      else
3761                                                        {
3762                                                          /* 33222222222211111111110000000000
3763                                                             10987654321098765432109876543210
3764                                                             xx011001110xxxxx0101x1xxxxxxxxxx
3765                                                             setmt.  */
3766                                                          return 2614;
3767                                                        }
3768                                                    }
3769                                                  else
3770                                                    {
3771                                                      /* 33222222222211111111110000000000
3772                                                         10987654321098765432109876543210
3773                                                         xx0110011x0xxxxx1101x1xxxxxxxxxx
3774                                                         cpyfewtn.  */
3775                                                      return 2537;
3776                                                    }
3777                                                }
3778                                            }
3779                                          else
3780                                            {
3781                                              if (((word >> 14) & 0x1) == 0)
3782                                                {
3783                                                  if (((word >> 15) & 0x1) == 0)
3784                                                    {
3785                                                      if (((word >> 22) & 0x1) == 0)
3786                                                        {
3787                                                          /* 33222222222211111111110000000000
3788                                                             10987654321098765432109876543210
3789                                                             xx011001100xxxxx0011x1xxxxxxxxxx
3790                                                             cpyfet.  */
3791                                                          return 2552;
3792                                                        }
3793                                                      else
3794                                                        {
3795                                                          /* 33222222222211111111110000000000
3796                                                             10987654321098765432109876543210
3797                                                             xx011001110xxxxx0011x1xxxxxxxxxx
3798                                                             setptn.  */
3799                                                          return 2619;
3800                                                        }
3801                                                    }
3802                                                  else
3803                                                    {
3804                                                      if (((word >> 22) & 0x1) == 0)
3805                                                        {
3806                                                          /* 33222222222211111111110000000000
3807                                                             10987654321098765432109876543210
3808                                                             xx011001100xxxxx1011x1xxxxxxxxxx
3809                                                             cpyfetrn.  */
3810                                                          return 2558;
3811                                                        }
3812                                                      else
3813                                                        {
3814                                                          /* 33222222222211111111110000000000
3815                                                             10987654321098765432109876543210
3816                                                             xx011001110xxxxx1011x1xxxxxxxxxx
3817                                                             setetn.  */
3818                                                          return 2621;
3819                                                        }
3820                                                    }
3821                                                }
3822                                              else
3823                                                {
3824                                                  if (((word >> 15) & 0x1) == 0)
3825                                                    {
3826                                                      if (((word >> 22) & 0x1) == 0)
3827                                                        {
3828                                                          /* 33222222222211111111110000000000
3829                                                             10987654321098765432109876543210
3830                                                             xx011001100xxxxx0111x1xxxxxxxxxx
3831                                                             cpyfetwn.  */
3832                                                          return 2555;
3833                                                        }
3834                                                      else
3835                                                        {
3836                                                          /* 33222222222211111111110000000000
3837                                                             10987654321098765432109876543210
3838                                                             xx011001110xxxxx0111x1xxxxxxxxxx
3839                                                             setmtn.  */
3840                                                          return 2620;
3841                                                        }
3842                                                    }
3843                                                  else
3844                                                    {
3845                                                      /* 33222222222211111111110000000000
3846                                                         10987654321098765432109876543210
3847                                                         xx0110011x0xxxxx1111x1xxxxxxxxxx
3848                                                         cpyfetn.  */
3849                                                      return 2561;
3850                                                    }
3851                                                }
3852                                            }
3853                                        }
3854                                    }
3855                                  else
3856                                    {
3857                                      if (((word >> 22) & 0x1) == 0)
3858                                        {
3859                                          /* 33222222222211111111110000000000
3860                                             10987654321098765432109876543210
3861                                             xx011001101xxxxxxxxxx1xxxxxxxxxx
3862                                             st2g.  */
3863                                          return 887;
3864                                        }
3865                                      else
3866                                        {
3867                                          /* 33222222222211111111110000000000
3868                                             10987654321098765432109876543210
3869                                             xx011001111xxxxxxxxxx1xxxxxxxxxx
3870                                             stz2g.  */
3871                                          return 888;
3872                                        }
3873                                    }
3874                                }
3875                            }
3876                          else
3877                            {
3878                              if (((word >> 30) & 0x1) == 0)
3879                                {
3880                                  if (((word >> 31) & 0x1) == 0)
3881                                    {
3882                                      /* 33222222222211111111110000000000
3883                                         10987654321098765432109876543210
3884                                         001110011xxxxxxxxxxxxxxxxxxxxxxx
3885                                         ldrsb.  */
3886                                      return 891;
3887                                    }
3888                                  else
3889                                    {
3890                                      /* 33222222222211111111110000000000
3891                                         10987654321098765432109876543210
3892                                         101110011xxxxxxxxxxxxxxxxxxxxxxx
3893                                         ldrsw.  */
3894                                      return 899;
3895                                    }
3896                                }
3897                              else
3898                                {
3899                                  if (((word >> 31) & 0x1) == 0)
3900                                    {
3901                                      /* 33222222222211111111110000000000
3902                                         10987654321098765432109876543210
3903                                         011110011xxxxxxxxxxxxxxxxxxxxxxx
3904                                         ldrsh.  */
3905                                      return 896;
3906                                    }
3907                                  else
3908                                    {
3909                                      /* 33222222222211111111110000000000
3910                                         10987654321098765432109876543210
3911                                         111110011xxxxxxxxxxxxxxxxxxxxxxx
3912                                         prfm.  */
3913                                      return 900;
3914                                    }
3915                                }
3916                            }
3917                        }
3918                    }
3919                }
3920            }
3921        }
3922      else
3923        {
3924          if (((word >> 24) & 0x1) == 0)
3925            {
3926              if (((word >> 27) & 0x1) == 0)
3927                {
3928                  if (((word >> 23) & 0x1) == 0)
3929                    {
3930                      if (((word >> 29) & 0x1) == 0)
3931                        {
3932                          if (((word >> 30) & 0x1) == 0)
3933                            {
3934                              /* 33222222222211111111110000000000
3935                                 10987654321098765432109876543210
3936                                 x00x00100xxxxxxxxxxxxxxxxxxxxxxx
3937                                 and.  */
3938                              return 995;
3939                            }
3940                          else
3941                            {
3942                              /* 33222222222211111111110000000000
3943                                 10987654321098765432109876543210
3944                                 x10x00100xxxxxxxxxxxxxxxxxxxxxxx
3945                                 eor.  */
3946                              return 999;
3947                            }
3948                        }
3949                      else
3950                        {
3951                          if (((word >> 30) & 0x1) == 0)
3952                            {
3953                              /* 33222222222211111111110000000000
3954                                 10987654321098765432109876543210
3955                                 x01x00100xxxxxxxxxxxxxxxxxxxxxxx
3956                                 orr.  */
3957                              return 997;
3958                            }
3959                          else
3960                            {
3961                              /* 33222222222211111111110000000000
3962                                 10987654321098765432109876543210
3963                                 x11x00100xxxxxxxxxxxxxxxxxxxxxxx
3964                                 ands.  */
3965                              return 1000;
3966                            }
3967                        }
3968                    }
3969                  else
3970                    {
3971                      if (((word >> 29) & 0x1) == 0)
3972                        {
3973                          if (((word >> 30) & 0x1) == 0)
3974                            {
3975                              /* 33222222222211111111110000000000
3976                                 10987654321098765432109876543210
3977                                 x00x00101xxxxxxxxxxxxxxxxxxxxxxx
3978                                 movn.  */
3979                              return 1186;
3980                            }
3981                          else
3982                            {
3983                              /* 33222222222211111111110000000000
3984                                 10987654321098765432109876543210
3985                                 x10x00101xxxxxxxxxxxxxxxxxxxxxxx
3986                                 movz.  */
3987                              return 1188;
3988                            }
3989                        }
3990                      else
3991                        {
3992                          /* 33222222222211111111110000000000
3993                             10987654321098765432109876543210
3994                             xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
3995                             movk.  */
3996                          return 1190;
3997                        }
3998                    }
3999                }
4000              else
4001                {
4002                  if (((word >> 21) & 0x1) == 0)
4003                    {
4004                      if (((word >> 28) & 0x1) == 0)
4005                        {
4006                          if (((word >> 29) & 0x1) == 0)
4007                            {
4008                              if (((word >> 30) & 0x1) == 0)
4009                                {
4010                                  /* 33222222222211111111110000000000
4011                                     10987654321098765432109876543210
4012                                     x0001010xx0xxxxxxxxxxxxxxxxxxxxx
4013                                     and.  */
4014                                  return 1002;
4015                                }
4016                              else
4017                                {
4018                                  /* 33222222222211111111110000000000
4019                                     10987654321098765432109876543210
4020                                     x1001010xx0xxxxxxxxxxxxxxxxxxxxx
4021                                     eor.  */
4022                                  return 1009;
4023                                }
4024                            }
4025                          else
4026                            {
4027                              if (((word >> 30) & 0x1) == 0)
4028                                {
4029                                  /* 33222222222211111111110000000000
4030                                     10987654321098765432109876543210
4031                                     x0101010xx0xxxxxxxxxxxxxxxxxxxxx
4032                                     orr.  */
4033                                  return 1004;
4034                                }
4035                              else
4036                                {
4037                                  /* 33222222222211111111110000000000
4038                                     10987654321098765432109876543210
4039                                     x1101010xx0xxxxxxxxxxxxxxxxxxxxx
4040                                     ands.  */
4041                                  return 1011;
4042                                }
4043                            }
4044                        }
4045                      else
4046                        {
4047                          if (((word >> 10) & 0x1) == 0)
4048                            {
4049                              if (((word >> 11) & 0x1) == 0)
4050                                {
4051                                  if (((word >> 22) & 0x1) == 0)
4052                                    {
4053                                      if (((word >> 23) & 0x1) == 0)
4054                                        {
4055                                          if (((word >> 29) & 0x1) == 0)
4056                                            {
4057                                              if (((word >> 30) & 0x1) == 0)
4058                                                {
4059                                                  /* 33222222222211111111110000000000
4060                                                     10987654321098765432109876543210
4061                                                     x0011010000xxxxxxxxx00xxxxxxxxxx
4062                                                     adc.  */
4063                                                  return 0;
4064                                                }
4065                                              else
4066                                                {
4067                                                  /* 33222222222211111111110000000000
4068                                                     10987654321098765432109876543210
4069                                                     x1011010000xxxxxxxxx00xxxxxxxxxx
4070                                                     sbc.  */
4071                                                  return 2;
4072                                                }
4073                                            }
4074                                          else
4075                                            {
4076                                              if (((word >> 30) & 0x1) == 0)
4077                                                {
4078                                                  /* 33222222222211111111110000000000
4079                                                     10987654321098765432109876543210
4080                                                     x0111010000xxxxxxxxx00xxxxxxxxxx
4081                                                     adcs.  */
4082                                                  return 1;
4083                                                }
4084                                              else
4085                                                {
4086                                                  /* 33222222222211111111110000000000
4087                                                     10987654321098765432109876543210
4088                                                     x1111010000xxxxxxxxx00xxxxxxxxxx
4089                                                     sbcs.  */
4090                                                  return 4;
4091                                                }
4092                                            }
4093                                        }
4094                                      else
4095                                        {
4096                                          if (((word >> 30) & 0x1) == 0)
4097                                            {
4098                                              /* 33222222222211111111110000000000
4099                                                 10987654321098765432109876543210
4100                                                 x0x11010100xxxxxxxxx00xxxxxxxxxx
4101                                                 csel.  */
4102                                              return 662;
4103                                            }
4104                                          else
4105                                            {
4106                                              /* 33222222222211111111110000000000
4107                                                 10987654321098765432109876543210
4108                                                 x1x11010100xxxxxxxxx00xxxxxxxxxx
4109                                                 csinv.  */
4110                                              return 666;
4111                                            }
4112                                        }
4113                                    }
4114                                  else
4115                                    {
4116                                      if (((word >> 23) & 0x1) == 0)
4117                                        {
4118                                          if (((word >> 30) & 0x1) == 0)
4119                                            {
4120                                              /* 33222222222211111111110000000000
4121                                                 10987654321098765432109876543210
4122                                                 x0x11010010xxxxxxxxx00xxxxxxxxxx
4123                                                 ccmn.  */
4124                                              return 660;
4125                                            }
4126                                          else
4127                                            {
4128                                              /* 33222222222211111111110000000000
4129                                                 10987654321098765432109876543210
4130                                                 x1x11010010xxxxxxxxx00xxxxxxxxxx
4131                                                 ccmp.  */
4132                                              return 661;
4133                                            }
4134                                        }
4135                                      else
4136                                        {
4137                                          if (((word >> 12) & 0x1) == 0)
4138                                            {
4139                                              if (((word >> 13) & 0x1) == 0)
4140                                                {
4141                                                  if (((word >> 14) & 0x1) == 0)
4142                                                    {
4143                                                      if (((word >> 29) & 0x1) == 0)
4144                                                        {
4145                                                          if (((word >> 30) & 0x1) == 0)
4146                                                            {
4147                                                              /* 33222222222211111111110000000000
4148                                                                 10987654321098765432109876543210
4149                                                                 x0011010110xxxxxx00000xxxxxxxxxx
4150                                                                 subp.  */
4151                                                              return 721;
4152                                                            }
4153                                                          else
4154                                                            {
4155                                                              if (((word >> 16) & 0x1) == 0)
4156                                                                {
4157                                                                  /* 33222222222211111111110000000000
4158                                                                     10987654321098765432109876543210
4159                                                                     x1011010110xxxx0x00000xxxxxxxxxx
4160                                                                     rbit.  */
4161                                                                  return 685;
4162                                                                }
4163                                                              else
4164                                                                {
4165                                                                  /* 33222222222211111111110000000000
4166                                                                     10987654321098765432109876543210
4167                                                                     x1011010110xxxx1x00000xxxxxxxxxx
4168                                                                     pacia.  */
4169                                                                  return 693;
4170                                                                }
4171                                                            }
4172                                                        }
4173                                                      else
4174                                                        {
4175                                                          /* 33222222222211111111110000000000
4176                                                             10987654321098765432109876543210
4177                                                             xx111010110xxxxxx00000xxxxxxxxxx
4178                                                             subps.  */
4179                                                          return 722;
4180                                                        }
4181                                                    }
4182                                                  else
4183                                                    {
4184                                                      if (((word >> 30) & 0x1) == 0)
4185                                                        {
4186                                                          /* 33222222222211111111110000000000
4187                                                             10987654321098765432109876543210
4188                                                             x0x11010110xxxxxx10000xxxxxxxxxx
4189                                                             crc32b.  */
4190                                                          return 727;
4191                                                        }
4192                                                      else
4193                                                        {
4194                                                          /* 33222222222211111111110000000000
4195                                                             10987654321098765432109876543210
4196                                                             x1x11010110xxxxxx10000xxxxxxxxxx
4197                                                             xpaci.  */
4198                                                          return 709;
4199                                                        }
4200                                                    }
4201                                                }
4202                                              else
4203                                                {
4204                                                  if (((word >> 30) & 0x1) == 0)
4205                                                    {
4206                                                      /* 33222222222211111111110000000000
4207                                                         10987654321098765432109876543210
4208                                                         x0x11010110xxxxxxx1000xxxxxxxxxx
4209                                                         lslv.  */
4210                                                      return 713;
4211                                                    }
4212                                                  else
4213                                                    {
4214                                                      /* 33222222222211111111110000000000
4215                                                         10987654321098765432109876543210
4216                                                         x1x11010110xxxxxxx1000xxxxxxxxxx
4217                                                         paciza.  */
4218                                                      return 701;
4219                                                    }
4220                                                }
4221                                            }
4222                                          else
4223                                            {
4224                                              if (((word >> 13) & 0x1) == 0)
4225                                                {
4226                                                  if (((word >> 14) & 0x1) == 0)
4227                                                    {
4228                                                      if (((word >> 30) & 0x1) == 0)
4229                                                        {
4230                                                          /* 33222222222211111111110000000000
4231                                                             10987654321098765432109876543210
4232                                                             x0x11010110xxxxxx00100xxxxxxxxxx
4233                                                             irg.  */
4234                                                          return 724;
4235                                                        }
4236                                                      else
4237                                                        {
4238                                                          if (((word >> 16) & 0x1) == 0)
4239                                                            {
4240                                                              /* 33222222222211111111110000000000
4241                                                                 10987654321098765432109876543210
4242                                                                 x1x11010110xxxx0x00100xxxxxxxxxx
4243                                                                 clz.  */
4244                                                              return 690;
4245                                                            }
4246                                                          else
4247                                                            {
4248                                                              /* 33222222222211111111110000000000
4249                                                                 10987654321098765432109876543210
4250                                                                 x1x11010110xxxx1x00100xxxxxxxxxx
4251                                                                 autia.  */
4252                                                              return 697;
4253                                                            }
4254                                                        }
4255                                                    }
4256                                                  else
4257                                                    {
4258                                                      /* 33222222222211111111110000000000
4259                                                         10987654321098765432109876543210
4260                                                         xxx11010110xxxxxx10100xxxxxxxxxx
4261                                                         crc32cb.  */
4262                                                      return 731;
4263                                                    }
4264                                                }
4265                                              else
4266                                                {
4267                                                  if (((word >> 30) & 0x1) == 0)
4268                                                    {
4269                                                      /* 33222222222211111111110000000000
4270                                                         10987654321098765432109876543210
4271                                                         x0x11010110xxxxxxx1100xxxxxxxxxx
4272                                                         pacga.  */
4273                                                      return 726;
4274                                                    }
4275                                                  else
4276                                                    {
4277                                                      /* 33222222222211111111110000000000
4278                                                         10987654321098765432109876543210
4279                                                         x1x11010110xxxxxxx1100xxxxxxxxxx
4280                                                         autiza.  */
4281                                                      return 705;
4282                                                    }
4283                                                }
4284                                            }
4285                                        }
4286                                    }
4287                                }
4288                              else
4289                                {
4290                                  if (((word >> 22) & 0x1) == 0)
4291                                    {
4292                                      if (((word >> 14) & 0x1) == 0)
4293                                        {
4294                                          /* 33222222222211111111110000000000
4295                                             10987654321098765432109876543210
4296                                             xxx11010x00xxxxxx0xx10xxxxxxxxxx
4297                                             setf8.  */
4298                                          return 2452;
4299                                        }
4300                                      else
4301                                        {
4302                                          /* 33222222222211111111110000000000
4303                                             10987654321098765432109876543210
4304                                             xxx11010x00xxxxxx1xx10xxxxxxxxxx
4305                                             setf16.  */
4306                                          return 2453;
4307                                        }
4308                                    }
4309                                  else
4310                                    {
4311                                      if (((word >> 23) & 0x1) == 0)
4312                                        {
4313                                          if (((word >> 30) & 0x1) == 0)
4314                                            {
4315                                              /* 33222222222211111111110000000000
4316                                                 10987654321098765432109876543210
4317                                                 x0x11010010xxxxxxxxx10xxxxxxxxxx
4318                                                 ccmn.  */
4319                                              return 658;
4320                                            }
4321                                          else
4322                                            {
4323                                              /* 33222222222211111111110000000000
4324                                                 10987654321098765432109876543210
4325                                                 x1x11010010xxxxxxxxx10xxxxxxxxxx
4326                                                 ccmp.  */
4327                                              return 659;
4328                                            }
4329                                        }
4330                                      else
4331                                        {
4332                                          if (((word >> 12) & 0x1) == 0)
4333                                            {
4334                                              if (((word >> 13) & 0x1) == 0)
4335                                                {
4336                                                  if (((word >> 14) & 0x1) == 0)
4337                                                    {
4338                                                      if (((word >> 30) & 0x1) == 0)
4339                                                        {
4340                                                          /* 33222222222211111111110000000000
4341                                                             10987654321098765432109876543210
4342                                                             x0x11010110xxxxxx00010xxxxxxxxxx
4343                                                             udiv.  */
4344                                                          return 711;
4345                                                        }
4346                                                      else
4347                                                        {
4348                                                          if (((word >> 16) & 0x1) == 0)
4349                                                            {
4350                                                              if (((word >> 31) & 0x1) == 0)
4351                                                                {
4352                                                                  /* 33222222222211111111110000000000
4353                                                                     10987654321098765432109876543210
4354                                                                     01x11010110xxxx0x00010xxxxxxxxxx
4355                                                                     rev.  */
4356                                                                  return 687;
4357                                                                }
4358                                                              else
4359                                                                {
4360                                                                  /* 33222222222211111111110000000000
4361                                                                     10987654321098765432109876543210
4362                                                                     11x11010110xxxx0x00010xxxxxxxxxx
4363                                                                     rev32.  */
4364                                                                  return 692;
4365                                                                }
4366                                                            }
4367                                                          else
4368                                                            {
4369                                                              /* 33222222222211111111110000000000
4370                                                                 10987654321098765432109876543210
4371                                                                 x1x11010110xxxx1x00010xxxxxxxxxx
4372                                                                 pacda.  */
4373                                                              return 695;
4374                                                            }
4375                                                        }
4376                                                    }
4377                                                  else
4378                                                    {
4379                                                      /* 33222222222211111111110000000000
4380                                                         10987654321098765432109876543210
4381                                                         xxx11010110xxxxxx10010xxxxxxxxxx
4382                                                         crc32w.  */
4383                                                      return 729;
4384                                                    }
4385                                                }
4386                                              else
4387                                                {
4388                                                  if (((word >> 30) & 0x1) == 0)
4389                                                    {
4390                                                      /* 33222222222211111111110000000000
4391                                                         10987654321098765432109876543210
4392                                                         x0x11010110xxxxxxx1010xxxxxxxxxx
4393                                                         asrv.  */
4394                                                      return 717;
4395                                                    }
4396                                                  else
4397                                                    {
4398                                                      /* 33222222222211111111110000000000
4399                                                         10987654321098765432109876543210
4400                                                         x1x11010110xxxxxxx1010xxxxxxxxxx
4401                                                         pacdza.  */
4402                                                      return 703;
4403                                                    }
4404                                                }
4405                                            }
4406                                          else
4407                                            {
4408                                              if (((word >> 13) & 0x1) == 0)
4409                                                {
4410                                                  if (((word >> 14) & 0x1) == 0)
4411                                                    {
4412                                                      /* 33222222222211111111110000000000
4413                                                         10987654321098765432109876543210
4414                                                         xxx11010110xxxxxx00110xxxxxxxxxx
4415                                                         autda.  */
4416                                                      return 699;
4417                                                    }
4418                                                  else
4419                                                    {
4420                                                      /* 33222222222211111111110000000000
4421                                                         10987654321098765432109876543210
4422                                                         xxx11010110xxxxxx10110xxxxxxxxxx
4423                                                         crc32cw.  */
4424                                                      return 733;
4425                                                    }
4426                                                }
4427                                              else
4428                                                {
4429                                                  /* 33222222222211111111110000000000
4430                                                     10987654321098765432109876543210
4431                                                     xxx11010110xxxxxxx1110xxxxxxxxxx
4432                                                     autdza.  */
4433                                                  return 707;
4434                                                }
4435                                            }
4436                                        }
4437                                    }
4438                                }
4439                            }
4440                          else
4441                            {
4442                              if (((word >> 11) & 0x1) == 0)
4443                                {
4444                                  if (((word >> 22) & 0x1) == 0)
4445                                    {
4446                                      if (((word >> 23) & 0x1) == 0)
4447                                        {
4448                                          /* 33222222222211111111110000000000
4449                                             10987654321098765432109876543210
4450                                             xxx11010000xxxxxxxxx01xxxxxxxxxx
4451                                             rmif.  */
4452                                          return 2451;
4453                                        }
4454                                      else
4455                                        {
4456                                          if (((word >> 30) & 0x1) == 0)
4457                                            {
4458                                              /* 33222222222211111111110000000000
4459                                                 10987654321098765432109876543210
4460                                                 x0x11010100xxxxxxxxx01xxxxxxxxxx
4461                                                 csinc.  */
4462                                              return 663;
4463                                            }
4464                                          else
4465                                            {
4466                                              /* 33222222222211111111110000000000
4467                                                 10987654321098765432109876543210
4468                                                 x1x11010100xxxxxxxxx01xxxxxxxxxx
4469                                                 csneg.  */
4470                                              return 669;
4471                                            }
4472                                        }
4473                                    }
4474                                  else
4475                                    {
4476                                      if (((word >> 12) & 0x1) == 0)
4477                                        {
4478                                          if (((word >> 13) & 0x1) == 0)
4479                                            {
4480                                              if (((word >> 14) & 0x1) == 0)
4481                                                {
4482                                                  if (((word >> 16) & 0x1) == 0)
4483                                                    {
4484                                                      /* 33222222222211111111110000000000
4485                                                         10987654321098765432109876543210
4486                                                         xxx11010x10xxxx0x00001xxxxxxxxxx
4487                                                         rev16.  */
4488                                                      return 686;
4489                                                    }
4490                                                  else
4491                                                    {
4492                                                      /* 33222222222211111111110000000000
4493                                                         10987654321098765432109876543210
4494                                                         xxx11010x10xxxx1x00001xxxxxxxxxx
4495                                                         pacib.  */
4496                                                      return 694;
4497                                                    }
4498                                                }
4499                                              else
4500                                                {
4501                                                  if (((word >> 30) & 0x1) == 0)
4502                                                    {
4503                                                      /* 33222222222211111111110000000000
4504                                                         10987654321098765432109876543210
4505                                                         x0x11010x10xxxxxx10001xxxxxxxxxx
4506                                                         crc32h.  */
4507                                                      return 728;
4508                                                    }
4509                                                  else
4510                                                    {
4511                                                      /* 33222222222211111111110000000000
4512                                                         10987654321098765432109876543210
4513                                                         x1x11010x10xxxxxx10001xxxxxxxxxx
4514                                                         xpacd.  */
4515                                                      return 710;
4516                                                    }
4517                                                }
4518                                            }
4519                                          else
4520                                            {
4521                                              if (((word >> 30) & 0x1) == 0)
4522                                                {
4523                                                  /* 33222222222211111111110000000000
4524                                                     10987654321098765432109876543210
4525                                                     x0x11010x10xxxxxxx1001xxxxxxxxxx
4526                                                     lsrv.  */
4527                                                  return 715;
4528                                                }
4529                                              else
4530                                                {
4531                                                  /* 33222222222211111111110000000000
4532                                                     10987654321098765432109876543210
4533                                                     x1x11010x10xxxxxxx1001xxxxxxxxxx
4534                                                     pacizb.  */
4535                                                  return 702;
4536                                                }
4537                                            }
4538                                        }
4539                                      else
4540                                        {
4541                                          if (((word >> 13) & 0x1) == 0)
4542                                            {
4543                                              if (((word >> 14) & 0x1) == 0)
4544                                                {
4545                                                  if (((word >> 30) & 0x1) == 0)
4546                                                    {
4547                                                      /* 33222222222211111111110000000000
4548                                                         10987654321098765432109876543210
4549                                                         x0x11010x10xxxxxx00101xxxxxxxxxx
4550                                                         gmi.  */
4551                                                      return 725;
4552                                                    }
4553                                                  else
4554                                                    {
4555                                                      if (((word >> 16) & 0x1) == 0)
4556                                                        {
4557                                                          /* 33222222222211111111110000000000
4558                                                             10987654321098765432109876543210
4559                                                             x1x11010x10xxxx0x00101xxxxxxxxxx
4560                                                             cls.  */
4561                                                          return 691;
4562                                                        }
4563                                                      else
4564                                                        {
4565                                                          /* 33222222222211111111110000000000
4566                                                             10987654321098765432109876543210
4567                                                             x1x11010x10xxxx1x00101xxxxxxxxxx
4568                                                             autib.  */
4569                                                          return 698;
4570                                                        }
4571                                                    }
4572                                                }
4573                                              else
4574                                                {
4575                                                  /* 33222222222211111111110000000000
4576                                                     10987654321098765432109876543210
4577                                                     xxx11010x10xxxxxx10101xxxxxxxxxx
4578                                                     crc32ch.  */
4579                                                  return 732;
4580                                                }
4581                                            }
4582                                          else
4583                                            {
4584                                              /* 33222222222211111111110000000000
4585                                                 10987654321098765432109876543210
4586                                                 xxx11010x10xxxxxxx1101xxxxxxxxxx
4587                                                 autizb.  */
4588                                              return 706;
4589                                            }
4590                                        }
4591                                    }
4592                                }
4593                              else
4594                                {
4595                                  if (((word >> 12) & 0x1) == 0)
4596                                    {
4597                                      if (((word >> 13) & 0x1) == 0)
4598                                        {
4599                                          if (((word >> 14) & 0x1) == 0)
4600                                            {
4601                                              if (((word >> 30) & 0x1) == 0)
4602                                                {
4603                                                  /* 33222222222211111111110000000000
4604                                                     10987654321098765432109876543210
4605                                                     x0x11010xx0xxxxxx00011xxxxxxxxxx
4606                                                     sdiv.  */
4607                                                  return 712;
4608                                                }
4609                                              else
4610                                                {
4611                                                  if (((word >> 16) & 0x1) == 0)
4612                                                    {
4613                                                      /* 33222222222211111111110000000000
4614                                                         10987654321098765432109876543210
4615                                                         x1x11010xx0xxxx0x00011xxxxxxxxxx
4616                                                         rev.  */
4617                                                      return 688;
4618                                                    }
4619                                                  else
4620                                                    {
4621                                                      /* 33222222222211111111110000000000
4622                                                         10987654321098765432109876543210
4623                                                         x1x11010xx0xxxx1x00011xxxxxxxxxx
4624                                                         pacdb.  */
4625                                                      return 696;
4626                                                    }
4627                                                }
4628                                            }
4629                                          else
4630                                            {
4631                                              /* 33222222222211111111110000000000
4632                                                 10987654321098765432109876543210
4633                                                 xxx11010xx0xxxxxx10011xxxxxxxxxx
4634                                                 crc32x.  */
4635                                              return 730;
4636                                            }
4637                                        }
4638                                      else
4639                                        {
4640                                          if (((word >> 30) & 0x1) == 0)
4641                                            {
4642                                              /* 33222222222211111111110000000000
4643                                                 10987654321098765432109876543210
4644                                                 x0x11010xx0xxxxxxx1011xxxxxxxxxx
4645                                                 rorv.  */
4646                                              return 719;
4647                                            }
4648                                          else
4649                                            {
4650                                              /* 33222222222211111111110000000000
4651                                                 10987654321098765432109876543210
4652                                                 x1x11010xx0xxxxxxx1011xxxxxxxxxx
4653                                                 pacdzb.  */
4654                                              return 704;
4655                                            }
4656                                        }
4657                                    }
4658                                  else
4659                                    {
4660                                      if (((word >> 13) & 0x1) == 0)
4661                                        {
4662                                          if (((word >> 14) & 0x1) == 0)
4663                                            {
4664                                              /* 33222222222211111111110000000000
4665                                                 10987654321098765432109876543210
4666                                                 xxx11010xx0xxxxxx00111xxxxxxxxxx
4667                                                 autdb.  */
4668                                              return 700;
4669                                            }
4670                                          else
4671                                            {
4672                                              /* 33222222222211111111110000000000
4673                                                 10987654321098765432109876543210
4674                                                 xxx11010xx0xxxxxx10111xxxxxxxxxx
4675                                                 crc32cx.  */
4676                                              return 734;
4677                                            }
4678                                        }
4679                                      else
4680                                        {
4681                                          /* 33222222222211111111110000000000
4682                                             10987654321098765432109876543210
4683                                             xxx11010xx0xxxxxxx1111xxxxxxxxxx
4684                                             autdzb.  */
4685                                          return 708;
4686                                        }
4687                                    }
4688                                }
4689                            }
4690                        }
4691                    }
4692                  else
4693                    {
4694                      if (((word >> 29) & 0x1) == 0)
4695                        {
4696                          if (((word >> 30) & 0x1) == 0)
4697                            {
4698                              /* 33222222222211111111110000000000
4699                                 10987654321098765432109876543210
4700                                 x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
4701                                 bic.  */
4702                              return 1003;
4703                            }
4704                          else
4705                            {
4706                              /* 33222222222211111111110000000000
4707                                 10987654321098765432109876543210
4708                                 x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
4709                                 eon.  */
4710                              return 1010;
4711                            }
4712                        }
4713                      else
4714                        {
4715                          if (((word >> 30) & 0x1) == 0)
4716                            {
4717                              /* 33222222222211111111110000000000
4718                                 10987654321098765432109876543210
4719                                 x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
4720                                 orn.  */
4721                              return 1007;
4722                            }
4723                          else
4724                            {
4725                              /* 33222222222211111111110000000000
4726                                 10987654321098765432109876543210
4727                                 x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
4728                                 bics.  */
4729                              return 1013;
4730                            }
4731                        }
4732                    }
4733                }
4734            }
4735          else
4736            {
4737              if (((word >> 27) & 0x1) == 0)
4738                {
4739                  if (((word >> 23) & 0x1) == 0)
4740                    {
4741                      if (((word >> 29) & 0x1) == 0)
4742                        {
4743                          if (((word >> 30) & 0x1) == 0)
4744                            {
4745                              /* 33222222222211111111110000000000
4746                                 10987654321098765432109876543210
4747                                 x00x00110xxxxxxxxxxxxxxxxxxxxxxx
4748                                 sbfm.  */
4749                              return 618;
4750                            }
4751                          else
4752                            {
4753                              /* 33222222222211111111110000000000
4754                                 10987654321098765432109876543210
4755                                 x10x00110xxxxxxxxxxxxxxxxxxxxxxx
4756                                 ubfm.  */
4757                              return 629;
4758                            }
4759                        }
4760                      else
4761                        {
4762                          /* 33222222222211111111110000000000
4763                             10987654321098765432109876543210
4764                             xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
4765                             bfm.  */
4766                          return 625;
4767                        }
4768                    }
4769                  else
4770                    {
4771                      /* 33222222222211111111110000000000
4772                         10987654321098765432109876543210
4773                         xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
4774                         extr.  */
4775                      return 758;
4776                    }
4777                }
4778              else
4779                {
4780                  if (((word >> 21) & 0x1) == 0)
4781                    {
4782                      if (((word >> 28) & 0x1) == 0)
4783                        {
4784                          if (((word >> 29) & 0x1) == 0)
4785                            {
4786                              if (((word >> 30) & 0x1) == 0)
4787                                {
4788                                  /* 33222222222211111111110000000000
4789                                     10987654321098765432109876543210
4790                                     x0001011xx0xxxxxxxxxxxxxxxxxxxxx
4791                                     add.  */
4792                                  return 21;
4793                                }
4794                              else
4795                                {
4796                                  /* 33222222222211111111110000000000
4797                                     10987654321098765432109876543210
4798                                     x1001011xx0xxxxxxxxxxxxxxxxxxxxx
4799                                     sub.  */
4800                                  return 24;
4801                                }
4802                            }
4803                          else
4804                            {
4805                              if (((word >> 30) & 0x1) == 0)
4806                                {
4807                                  /* 33222222222211111111110000000000
4808                                     10987654321098765432109876543210
4809                                     x0101011xx0xxxxxxxxxxxxxxxxxxxxx
4810                                     adds.  */
4811                                  return 22;
4812                                }
4813                              else
4814                                {
4815                                  /* 33222222222211111111110000000000
4816                                     10987654321098765432109876543210
4817                                     x1101011xx0xxxxxxxxxxxxxxxxxxxxx
4818                                     subs.  */
4819                                  return 26;
4820                                }
4821                            }
4822                        }
4823                      else
4824                        {
4825                          if (((word >> 15) & 0x1) == 0)
4826                            {
4827                              if (((word >> 22) & 0x1) == 0)
4828                                {
4829                                  /* 33222222222211111111110000000000
4830                                     10987654321098765432109876543210
4831                                     xxx11011x00xxxxx0xxxxxxxxxxxxxxx
4832                                     madd.  */
4833                                  return 735;
4834                                }
4835                              else
4836                                {
4837                                  if (((word >> 23) & 0x1) == 0)
4838                                    {
4839                                      /* 33222222222211111111110000000000
4840                                         10987654321098765432109876543210
4841                                         xxx11011010xxxxx0xxxxxxxxxxxxxxx
4842                                         smulh.  */
4843                                      return 743;
4844                                    }
4845                                  else
4846                                    {
4847                                      /* 33222222222211111111110000000000
4848                                         10987654321098765432109876543210
4849                                         xxx11011110xxxxx0xxxxxxxxxxxxxxx
4850                                         umulh.  */
4851                                      return 748;
4852                                    }
4853                                }
4854                            }
4855                          else
4856                            {
4857                              /* 33222222222211111111110000000000
4858                                 10987654321098765432109876543210
4859                                 xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
4860                                 msub.  */
4861                              return 737;
4862                            }
4863                        }
4864                    }
4865                  else
4866                    {
4867                      if (((word >> 23) & 0x1) == 0)
4868                        {
4869                          if (((word >> 28) & 0x1) == 0)
4870                            {
4871                              if (((word >> 29) & 0x1) == 0)
4872                                {
4873                                  if (((word >> 30) & 0x1) == 0)
4874                                    {
4875                                      /* 33222222222211111111110000000000
4876                                         10987654321098765432109876543210
4877                                         x00010110x1xxxxxxxxxxxxxxxxxxxxx
4878                                         add.  */
4879                                      return 6;
4880                                    }
4881                                  else
4882                                    {
4883                                      /* 33222222222211111111110000000000
4884                                         10987654321098765432109876543210
4885                                         x10010110x1xxxxxxxxxxxxxxxxxxxxx
4886                                         sub.  */
4887                                      return 9;
4888                                    }
4889                                }
4890                              else
4891                                {
4892                                  if (((word >> 30) & 0x1) == 0)
4893                                    {
4894                                      /* 33222222222211111111110000000000
4895                                         10987654321098765432109876543210
4896                                         x01010110x1xxxxxxxxxxxxxxxxxxxxx
4897                                         adds.  */
4898                                      return 7;
4899                                    }
4900                                  else
4901                                    {
4902                                      /* 33222222222211111111110000000000
4903                                         10987654321098765432109876543210
4904                                         x11010110x1xxxxxxxxxxxxxxxxxxxxx
4905                                         subs.  */
4906                                      return 10;
4907                                    }
4908                                }
4909                            }
4910                          else
4911                            {
4912                              if (((word >> 15) & 0x1) == 0)
4913                                {
4914                                  /* 33222222222211111111110000000000
4915                                     10987654321098765432109876543210
4916                                     xxx110110x1xxxxx0xxxxxxxxxxxxxxx
4917                                     smaddl.  */
4918                                  return 739;
4919                                }
4920                              else
4921                                {
4922                                  /* 33222222222211111111110000000000
4923                                     10987654321098765432109876543210
4924                                     xxx110110x1xxxxx1xxxxxxxxxxxxxxx
4925                                     smsubl.  */
4926                                  return 741;
4927                                }
4928                            }
4929                        }
4930                      else
4931                        {
4932                          if (((word >> 15) & 0x1) == 0)
4933                            {
4934                              /* 33222222222211111111110000000000
4935                                 10987654321098765432109876543210
4936                                 xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
4937                                 umaddl.  */
4938                              return 744;
4939                            }
4940                          else
4941                            {
4942                              /* 33222222222211111111110000000000
4943                                 10987654321098765432109876543210
4944                                 xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
4945                                 umsubl.  */
4946                              return 746;
4947                            }
4948                        }
4949                    }
4950                }
4951            }
4952        }
4953    }
4954  else
4955    {
4956      if (((word >> 27) & 0x1) == 0)
4957        {
4958          if (((word >> 28) & 0x1) == 0)
4959            {
4960              if (((word >> 24) & 0x1) == 0)
4961                {
4962                  if (((word >> 29) & 0x1) == 0)
4963                    {
4964                      if (((word >> 13) & 0x1) == 0)
4965                        {
4966                          if (((word >> 14) & 0x1) == 0)
4967                            {
4968                              if (((word >> 15) & 0x1) == 0)
4969                                {
4970                                  if (((word >> 21) & 0x1) == 0)
4971                                    {
4972                                      if (((word >> 30) & 0x1) == 0)
4973                                        {
4974                                          if (((word >> 31) & 0x1) == 0)
4975                                            {
4976                                              if (((word >> 16) & 0x1) == 0)
4977                                                {
4978                                                  if (((word >> 17) & 0x1) == 0)
4979                                                    {
4980                                                      if (((word >> 18) & 0x1) == 0)
4981                                                        {
4982                                                          if (((word >> 19) & 0x1) == 0)
4983                                                            {
4984                                                              if (((word >> 20) & 0x1) == 0)
4985                                                                {
4986                                                                  /* 33222222222211111111110000000000
4987                                                                     10987654321098765432109876543210
4988                                                                     000001x0xx000000000xxxxxxxxxxxxx
4989                                                                     add.  */
4990                                                                  return 1291;
4991                                                                }
4992                                                              else
4993                                                                {
4994                                                                  /* 33222222222211111111110000000000
4995                                                                     10987654321098765432109876543210
4996                                                                     000001x0xx010000000xxxxxxxxxxxxx
4997                                                                     mul.  */
4998                                                                  return 1760;
4999                                                                }
5000                                                            }
5001                                                          else
5002                                                            {
5003                                                              if (((word >> 20) & 0x1) == 0)
5004                                                                {
5005                                                                  /* 33222222222211111111110000000000
5006                                                                     10987654321098765432109876543210
5007                                                                     000001x0xx001000000xxxxxxxxxxxxx
5008                                                                     smax.  */
5009                                                                  return 1839;
5010                                                                }
5011                                                              else
5012                                                                {
5013                                                                  /* 33222222222211111111110000000000
5014                                                                     10987654321098765432109876543210
5015                                                                     000001x0xx011000000xxxxxxxxxxxxx
5016                                                                     orr.  */
5017                                                                  return 1771;
5018                                                                }
5019                                                            }
5020                                                        }
5021                                                      else
5022                                                        {
5023                                                          if (((word >> 19) & 0x1) == 0)
5024                                                            {
5025                                                              /* 33222222222211111111110000000000
5026                                                                 10987654321098765432109876543210
5027                                                                 000001x0xx0x0100000xxxxxxxxxxxxx
5028                                                                 sdiv.  */
5029                                                              return 1830;
5030                                                            }
5031                                                          else
5032                                                            {
5033                                                              /* 33222222222211111111110000000000
5034                                                                 10987654321098765432109876543210
5035                                                                 000001x0xx0x1100000xxxxxxxxxxxxx
5036                                                                 sabd.  */
5037                                                              return 1821;
5038                                                            }
5039                                                        }
5040                                                    }
5041                                                  else
5042                                                    {
5043                                                      if (((word >> 18) & 0x1) == 0)
5044                                                        {
5045                                                          if (((word >> 19) & 0x1) == 0)
5046                                                            {
5047                                                              /* 33222222222211111111110000000000
5048                                                                 10987654321098765432109876543210
5049                                                                 000001x0xx0x0010000xxxxxxxxxxxxx
5050                                                                 smulh.  */
5051                                                              return 1844;
5052                                                            }
5053                                                          else
5054                                                            {
5055                                                              if (((word >> 20) & 0x1) == 0)
5056                                                                {
5057                                                                  /* 33222222222211111111110000000000
5058                                                                     10987654321098765432109876543210
5059                                                                     000001x0xx001010000xxxxxxxxxxxxx
5060                                                                     smin.  */
5061                                                                  return 1842;
5062                                                                }
5063                                                              else
5064                                                                {
5065                                                                  /* 33222222222211111111110000000000
5066                                                                     10987654321098765432109876543210
5067                                                                     000001x0xx011010000xxxxxxxxxxxxx
5068                                                                     and.  */
5069                                                                  return 1299;
5070                                                                }
5071                                                            }
5072                                                        }
5073                                                      else
5074                                                        {
5075                                                          /* 33222222222211111111110000000000
5076                                                             10987654321098765432109876543210
5077                                                             000001x0xx0xx110000xxxxxxxxxxxxx
5078                                                             sdivr.  */
5079                                                          return 1831;
5080                                                        }
5081                                                    }
5082                                                }
5083                                              else
5084                                                {
5085                                                  if (((word >> 17) & 0x1) == 0)
5086                                                    {
5087                                                      if (((word >> 18) & 0x1) == 0)
5088                                                        {
5089                                                          if (((word >> 19) & 0x1) == 0)
5090                                                            {
5091                                                              /* 33222222222211111111110000000000
5092                                                                 10987654321098765432109876543210
5093                                                                 000001x0xx0x0001000xxxxxxxxxxxxx
5094                                                                 sub.  */
5095                                                              return 1960;
5096                                                            }
5097                                                          else
5098                                                            {
5099                                                              if (((word >> 20) & 0x1) == 0)
5100                                                                {
5101                                                                  /* 33222222222211111111110000000000
5102                                                                     10987654321098765432109876543210
5103                                                                     000001x0xx001001000xxxxxxxxxxxxx
5104                                                                     umax.  */
5105                                                                  return 1988;
5106                                                                }
5107                                                              else
5108                                                                {
5109                                                                  /* 33222222222211111111110000000000
5110                                                                     10987654321098765432109876543210
5111                                                                     000001x0xx011001000xxxxxxxxxxxxx
5112                                                                     eor.  */
5113                                                                  return 1386;
5114                                                                }
5115                                                            }
5116                                                        }
5117                                                      else
5118                                                        {
5119                                                          if (((word >> 19) & 0x1) == 0)
5120                                                            {
5121                                                              /* 33222222222211111111110000000000
5122                                                                 10987654321098765432109876543210
5123                                                                 000001x0xx0x0101000xxxxxxxxxxxxx
5124                                                                 udiv.  */
5125                                                              return 1982;
5126                                                            }
5127                                                          else
5128                                                            {
5129                                                              /* 33222222222211111111110000000000
5130                                                                 10987654321098765432109876543210
5131                                                                 000001x0xx0x1101000xxxxxxxxxxxxx
5132                                                                 uabd.  */
5133                                                              return 1973;
5134                                                            }
5135                                                        }
5136                                                    }
5137                                                  else
5138                                                    {
5139                                                      if (((word >> 18) & 0x1) == 0)
5140                                                        {
5141                                                          if (((word >> 19) & 0x1) == 0)
5142                                                            {
5143                                                              if (((word >> 20) & 0x1) == 0)
5144                                                                {
5145                                                                  /* 33222222222211111111110000000000
5146                                                                     10987654321098765432109876543210
5147                                                                     000001x0xx000011000xxxxxxxxxxxxx
5148                                                                     subr.  */
5149                                                                  return 1962;
5150                                                                }
5151                                                              else
5152                                                                {
5153                                                                  /* 33222222222211111111110000000000
5154                                                                     10987654321098765432109876543210
5155                                                                     000001x0xx010011000xxxxxxxxxxxxx
5156                                                                     umulh.  */
5157                                                                  return 1993;
5158                                                                }
5159                                                            }
5160                                                          else
5161                                                            {
5162                                                              if (((word >> 20) & 0x1) == 0)
5163                                                                {
5164                                                                  /* 33222222222211111111110000000000
5165                                                                     10987654321098765432109876543210
5166                                                                     000001x0xx001011000xxxxxxxxxxxxx
5167                                                                     umin.  */
5168                                                                  return 1991;
5169                                                                }
5170                                                              else
5171                                                                {
5172                                                                  /* 33222222222211111111110000000000
5173                                                                     10987654321098765432109876543210
5174                                                                     000001x0xx011011000xxxxxxxxxxxxx
5175                                                                     bic.  */
5176                                                                  return 1311;
5177                                                                }
5178                                                            }
5179                                                        }
5180                                                      else
5181                                                        {
5182                                                          /* 33222222222211111111110000000000
5183                                                             10987654321098765432109876543210
5184                                                             000001x0xx0xx111000xxxxxxxxxxxxx
5185                                                             udivr.  */
5186                                                          return 1983;
5187                                                        }
5188                                                    }
5189                                                }
5190                                            }
5191                                          else
5192                                            {
5193                                              if (((word >> 23) & 0x1) == 0)
5194                                                {
5195                                                  /* 33222222222211111111110000000000
5196                                                     10987654321098765432109876543210
5197                                                     100001x00x0xxxxx000xxxxxxxxxxxxx
5198                                                     ld1sb.  */
5199                                                  return 1573;
5200                                                }
5201                                              else
5202                                                {
5203                                                  /* 33222222222211111111110000000000
5204                                                     10987654321098765432109876543210
5205                                                     100001x01x0xxxxx000xxxxxxxxxxxxx
5206                                                     ld1sh.  */
5207                                                  return 1584;
5208                                                }
5209                                            }
5210                                        }
5211                                      else
5212                                        {
5213                                          if (((word >> 31) & 0x1) == 0)
5214                                            {
5215                                              if (((word >> 12) & 0x1) == 0)
5216                                                {
5217                                                  if (((word >> 10) & 0x1) == 0)
5218                                                    {
5219                                                      if (((word >> 11) & 0x1) == 0)
5220                                                        {
5221                                                          /* 33222222222211111111110000000000
5222                                                             10987654321098765432109876543210
5223                                                             010001x0xx0xxxxx000000xxxxxxxxxx
5224                                                             sdot.  */
5225                                                          return 1832;
5226                                                        }
5227                                                      else
5228                                                        {
5229                                                          /* 33222222222211111111110000000000
5230                                                             10987654321098765432109876543210
5231                                                             010001x0xx0xxxxx000010xxxxxxxxxx
5232                                                             sqdmlalbt.  */
5233                                                          return 2182;
5234                                                        }
5235                                                    }
5236                                                  else
5237                                                    {
5238                                                      if (((word >> 11) & 0x1) == 0)
5239                                                        {
5240                                                          /* 33222222222211111111110000000000
5241                                                             10987654321098765432109876543210
5242                                                             010001x0xx0xxxxx000001xxxxxxxxxx
5243                                                             udot.  */
5244                                                          return 1984;
5245                                                        }
5246                                                      else
5247                                                        {
5248                                                          /* 33222222222211111111110000000000
5249                                                             10987654321098765432109876543210
5250                                                             010001x0xx0xxxxx000011xxxxxxxxxx
5251                                                             sqdmlslbt.  */
5252                                                          return 2189;
5253                                                        }
5254                                                    }
5255                                                }
5256                                              else
5257                                                {
5258                                                  /* 33222222222211111111110000000000
5259                                                     10987654321098765432109876543210
5260                                                     010001x0xx0xxxxx0001xxxxxxxxxxxx
5261                                                     cdot.  */
5262                                                  return 2071;
5263                                                }
5264                                            }
5265                                          else
5266                                            {
5267                                              if (((word >> 23) & 0x1) == 0)
5268                                                {
5269                                                  /* 33222222222211111111110000000000
5270                                                     10987654321098765432109876543210
5271                                                     110001x00x0xxxxx000xxxxxxxxxxxxx
5272                                                     ld1sb.  */
5273                                                  return 1577;
5274                                                }
5275                                              else
5276                                                {
5277                                                  /* 33222222222211111111110000000000
5278                                                     10987654321098765432109876543210
5279                                                     110001x01x0xxxxx000xxxxxxxxxxxxx
5280                                                     ld1sh.  */
5281                                                  return 1588;
5282                                                }
5283                                            }
5284                                        }
5285                                    }
5286                                  else
5287                                    {
5288                                      if (((word >> 30) & 0x1) == 0)
5289                                        {
5290                                          if (((word >> 31) & 0x1) == 0)
5291                                            {
5292                                              if (((word >> 10) & 0x1) == 0)
5293                                                {
5294                                                  if (((word >> 11) & 0x1) == 0)
5295                                                    {
5296                                                      if (((word >> 12) & 0x1) == 0)
5297                                                        {
5298                                                          /* 33222222222211111111110000000000
5299                                                             10987654321098765432109876543210
5300                                                             000001x0xx1xxxxx000000xxxxxxxxxx
5301                                                             add.  */
5302                                                          return 1289;
5303                                                        }
5304                                                      else
5305                                                        {
5306                                                          /* 33222222222211111111110000000000
5307                                                             10987654321098765432109876543210
5308                                                             000001x0xx1xxxxx000100xxxxxxxxxx
5309                                                             sqadd.  */
5310                                                          return 1846;
5311                                                        }
5312                                                    }
5313                                                  else
5314                                                    {
5315                                                      /* 33222222222211111111110000000000
5316                                                         10987654321098765432109876543210
5317                                                         000001x0xx1xxxxx000x10xxxxxxxxxx
5318                                                         sqsub.  */
5319                                                      return 1876;
5320                                                    }
5321                                                }
5322                                              else
5323                                                {
5324                                                  if (((word >> 11) & 0x1) == 0)
5325                                                    {
5326                                                      if (((word >> 12) & 0x1) == 0)
5327                                                        {
5328                                                          /* 33222222222211111111110000000000
5329                                                             10987654321098765432109876543210
5330                                                             000001x0xx1xxxxx000001xxxxxxxxxx
5331                                                             sub.  */
5332                                                          return 1958;
5333                                                        }
5334                                                      else
5335                                                        {
5336                                                          /* 33222222222211111111110000000000
5337                                                             10987654321098765432109876543210
5338                                                             000001x0xx1xxxxx000101xxxxxxxxxx
5339                                                             uqadd.  */
5340                                                          return 1994;
5341                                                        }
5342                                                    }
5343                                                  else
5344                                                    {
5345                                                      /* 33222222222211111111110000000000
5346                                                         10987654321098765432109876543210
5347                                                         000001x0xx1xxxxx000x11xxxxxxxxxx
5348                                                         uqsub.  */
5349                                                      return 2024;
5350                                                    }
5351                                                }
5352                                            }
5353                                          else
5354                                            {
5355                                              if (((word >> 23) & 0x1) == 0)
5356                                                {
5357                                                  /* 33222222222211111111110000000000
5358                                                     10987654321098765432109876543210
5359                                                     100001x00x1xxxxx000xxxxxxxxxxxxx
5360                                                     prfb.  */
5361                                                  return 1779;
5362                                                }
5363                                              else
5364                                                {
5365                                                  /* 33222222222211111111110000000000
5366                                                     10987654321098765432109876543210
5367                                                     100001x01x1xxxxx000xxxxxxxxxxxxx
5368                                                     ld1sh.  */
5369                                                  return 1585;
5370                                                }
5371                                            }
5372                                        }
5373                                      else
5374                                        {
5375                                          if (((word >> 23) & 0x1) == 0)
5376                                            {
5377                                              if (((word >> 31) & 0x1) == 0)
5378                                                {
5379                                                  if (((word >> 10) & 0x1) == 0)
5380                                                    {
5381                                                      if (((word >> 11) & 0x1) == 0)
5382                                                        {
5383                                                          /* 33222222222211111111110000000000
5384                                                             10987654321098765432109876543210
5385                                                             010001x00x1xxxxx000x00xxxxxxxxxx
5386                                                             sqrdmlah.  */
5387                                                          return 2207;
5388                                                        }
5389                                                      else
5390                                                        {
5391                                                          /* 33222222222211111111110000000000
5392                                                             10987654321098765432109876543210
5393                                                             010001x00x1xxxxx000x10xxxxxxxxxx
5394                                                             mla.  */
5395                                                          return 2114;
5396                                                        }
5397                                                    }
5398                                                  else
5399                                                    {
5400                                                      if (((word >> 11) & 0x1) == 0)
5401                                                        {
5402                                                          /* 33222222222211111111110000000000
5403                                                             10987654321098765432109876543210
5404                                                             010001x00x1xxxxx000x01xxxxxxxxxx
5405                                                             sqrdmlsh.  */
5406                                                          return 2211;
5407                                                        }
5408                                                      else
5409                                                        {
5410                                                          /* 33222222222211111111110000000000
5411                                                             10987654321098765432109876543210
5412                                                             010001x00x1xxxxx000x11xxxxxxxxxx
5413                                                             mls.  */
5414                                                          return 2117;
5415                                                        }
5416                                                    }
5417                                                }
5418                                              else
5419                                                {
5420                                                  /* 33222222222211111111110000000000
5421                                                     10987654321098765432109876543210
5422                                                     110001x00x1xxxxx000xxxxxxxxxxxxx
5423                                                     prfb.  */
5424                                                  return 1780;
5425                                                }
5426                                            }
5427                                          else
5428                                            {
5429                                              if (((word >> 31) & 0x1) == 0)
5430                                                {
5431                                                  if (((word >> 10) & 0x1) == 0)
5432                                                    {
5433                                                      if (((word >> 11) & 0x1) == 0)
5434                                                        {
5435                                                          if (((word >> 12) & 0x1) == 0)
5436                                                            {
5437                                                              if (((word >> 22) & 0x1) == 0)
5438                                                                {
5439                                                                  /* 33222222222211111111110000000000
5440                                                                     10987654321098765432109876543210
5441                                                                     010001x0101xxxxx000000xxxxxxxxxx
5442                                                                     sdot.  */
5443                                                                  return 1833;
5444                                                                }
5445                                                              else
5446                                                                {
5447                                                                  /* 33222222222211111111110000000000
5448                                                                     10987654321098765432109876543210
5449                                                                     010001x0111xxxxx000000xxxxxxxxxx
5450                                                                     sdot.  */
5451                                                                  return 1834;
5452                                                                }
5453                                                            }
5454                                                          else
5455                                                            {
5456                                                              if (((word >> 22) & 0x1) == 0)
5457                                                                {
5458                                                                  /* 33222222222211111111110000000000
5459                                                                     10987654321098765432109876543210
5460                                                                     010001x0101xxxxx000100xxxxxxxxxx
5461                                                                     sqrdmlah.  */
5462                                                                  return 2208;
5463                                                                }
5464                                                              else
5465                                                                {
5466                                                                  /* 33222222222211111111110000000000
5467                                                                     10987654321098765432109876543210
5468                                                                     010001x0111xxxxx000100xxxxxxxxxx
5469                                                                     sqrdmlah.  */
5470                                                                  return 2209;
5471                                                                }
5472                                                            }
5473                                                        }
5474                                                      else
5475                                                        {
5476                                                          if (((word >> 12) & 0x1) == 0)
5477                                                            {
5478                                                              if (((word >> 22) & 0x1) == 0)
5479                                                                {
5480                                                                  /* 33222222222211111111110000000000
5481                                                                     10987654321098765432109876543210
5482                                                                     010001x0101xxxxx000010xxxxxxxxxx
5483                                                                     mla.  */
5484                                                                  return 2115;
5485                                                                }
5486                                                              else
5487                                                                {
5488                                                                  /* 33222222222211111111110000000000
5489                                                                     10987654321098765432109876543210
5490                                                                     010001x0111xxxxx000010xxxxxxxxxx
5491                                                                     mla.  */
5492                                                                  return 2116;
5493                                                                }
5494                                                            }
5495                                                          else
5496                                                            {
5497                                                              /* 33222222222211111111110000000000
5498                                                                 10987654321098765432109876543210
5499                                                                 010001x01x1xxxxx000110xxxxxxxxxx
5500                                                                 usdot.  */
5501                                                              return 2471;
5502                                                            }
5503                                                        }
5504                                                    }
5505                                                  else
5506                                                    {
5507                                                      if (((word >> 11) & 0x1) == 0)
5508                                                        {
5509                                                          if (((word >> 12) & 0x1) == 0)
5510                                                            {
5511                                                              if (((word >> 22) & 0x1) == 0)
5512                                                                {
5513                                                                  /* 33222222222211111111110000000000
5514                                                                     10987654321098765432109876543210
5515                                                                     010001x0101xxxxx000001xxxxxxxxxx
5516                                                                     udot.  */
5517                                                                  return 1985;
5518                                                                }
5519                                                              else
5520                                                                {
5521                                                                  /* 33222222222211111111110000000000
5522                                                                     10987654321098765432109876543210
5523                                                                     010001x0111xxxxx000001xxxxxxxxxx
5524                                                                     udot.  */
5525                                                                  return 1986;
5526                                                                }
5527                                                            }
5528                                                          else
5529                                                            {
5530                                                              if (((word >> 22) & 0x1) == 0)
5531                                                                {
5532                                                                  /* 33222222222211111111110000000000
5533                                                                     10987654321098765432109876543210
5534                                                                     010001x0101xxxxx000101xxxxxxxxxx
5535                                                                     sqrdmlsh.  */
5536                                                                  return 2212;
5537                                                                }
5538                                                              else
5539                                                                {
5540                                                                  /* 33222222222211111111110000000000
5541                                                                     10987654321098765432109876543210
5542                                                                     010001x0111xxxxx000101xxxxxxxxxx
5543                                                                     sqrdmlsh.  */
5544                                                                  return 2213;
5545                                                                }
5546                                                            }
5547                                                        }
5548                                                      else
5549                                                        {
5550                                                          if (((word >> 12) & 0x1) == 0)
5551                                                            {
5552                                                              if (((word >> 22) & 0x1) == 0)
5553                                                                {
5554                                                                  /* 33222222222211111111110000000000
5555                                                                     10987654321098765432109876543210
5556                                                                     010001x0101xxxxx000011xxxxxxxxxx
5557                                                                     mls.  */
5558                                                                  return 2118;
5559                                                                }
5560                                                              else
5561                                                                {
5562                                                                  /* 33222222222211111111110000000000
5563                                                                     10987654321098765432109876543210
5564                                                                     010001x0111xxxxx000011xxxxxxxxxx
5565                                                                     mls.  */
5566                                                                  return 2119;
5567                                                                }
5568                                                            }
5569                                                          else
5570                                                            {
5571                                                              /* 33222222222211111111110000000000
5572                                                                 10987654321098765432109876543210
5573                                                                 010001x01x1xxxxx000111xxxxxxxxxx
5574                                                                 sudot.  */
5575                                                              return 2472;
5576                                                            }
5577                                                        }
5578                                                    }
5579                                                }
5580                                              else
5581                                                {
5582                                                  /* 33222222222211111111110000000000
5583                                                     10987654321098765432109876543210
5584                                                     110001x01x1xxxxx000xxxxxxxxxxxxx
5585                                                     ld1sh.  */
5586                                                  return 1589;
5587                                                }
5588                                            }
5589                                        }
5590                                    }
5591                                }
5592                              else
5593                                {
5594                                  if (((word >> 31) & 0x1) == 0)
5595                                    {
5596                                      if (((word >> 21) & 0x1) == 0)
5597                                        {
5598                                          if (((word >> 16) & 0x1) == 0)
5599                                            {
5600                                              if (((word >> 17) & 0x1) == 0)
5601                                                {
5602                                                  if (((word >> 18) & 0x1) == 0)
5603                                                    {
5604                                                      if (((word >> 19) & 0x1) == 0)
5605                                                        {
5606                                                          if (((word >> 20) & 0x1) == 0)
5607                                                            {
5608                                                              /* 33222222222211111111110000000000
5609                                                                 10987654321098765432109876543210
5610                                                                 0x0001x0xx000000100xxxxxxxxxxxxx
5611                                                                 asr.  */
5612                                                              return 1307;
5613                                                            }
5614                                                          else
5615                                                            {
5616                                                              if (((word >> 30) & 0x1) == 0)
5617                                                                {
5618                                                                  /* 33222222222211111111110000000000
5619                                                                     10987654321098765432109876543210
5620                                                                     000001x0xx010000100xxxxxxxxxxxxx
5621                                                                     asr.  */
5622                                                                  return 1305;
5623                                                                }
5624                                                              else
5625                                                                {
5626                                                                  /* 33222222222211111111110000000000
5627                                                                     10987654321098765432109876543210
5628                                                                     010001x0xx010000100xxxxxxxxxxxxx
5629                                                                     shadd.  */
5630                                                                  return 2148;
5631                                                                }
5632                                                            }
5633                                                        }
5634                                                      else
5635                                                        {
5636                                                          if (((word >> 20) & 0x1) == 0)
5637                                                            {
5638                                                              /* 33222222222211111111110000000000
5639                                                                 10987654321098765432109876543210
5640                                                                 0x0001x0xx001000100xxxxxxxxxxxxx
5641                                                                 sqshl.  */
5642                                                              return 2226;
5643                                                            }
5644                                                          else
5645                                                            {
5646                                                              if (((word >> 30) & 0x1) == 0)
5647                                                                {
5648                                                                  /* 33222222222211111111110000000000
5649                                                                     10987654321098765432109876543210
5650                                                                     000001x0xx011000100xxxxxxxxxxxxx
5651                                                                     asr.  */
5652                                                                  return 1306;
5653                                                                }
5654                                                              else
5655                                                                {
5656                                                                  /* 33222222222211111111110000000000
5657                                                                     10987654321098765432109876543210
5658                                                                     010001x0xx011000100xxxxxxxxxxxxx
5659                                                                     sqadd.  */
5660                                                                  return 2177;
5661                                                                }
5662                                                            }
5663                                                        }
5664                                                    }
5665                                                  else
5666                                                    {
5667                                                      if (((word >> 19) & 0x1) == 0)
5668                                                        {
5669                                                          if (((word >> 20) & 0x1) == 0)
5670                                                            {
5671                                                              /* 33222222222211111111110000000000
5672                                                                 10987654321098765432109876543210
5673                                                                 0x0001x0xx000100100xxxxxxxxxxxxx
5674                                                                 asrd.  */
5675                                                              return 1308;
5676                                                            }
5677                                                          else
5678                                                            {
5679                                                              if (((word >> 30) & 0x1) == 0)
5680                                                                {
5681                                                                  /* 33222222222211111111110000000000
5682                                                                     10987654321098765432109876543210
5683                                                                     000001x0xx010100100xxxxxxxxxxxxx
5684                                                                     asrr.  */
5685                                                                  return 1309;
5686                                                                }
5687                                                              else
5688                                                                {
5689                                                                  /* 33222222222211111111110000000000
5690                                                                     10987654321098765432109876543210
5691                                                                     010001x0xx010100100xxxxxxxxxxxxx
5692                                                                     srhadd.  */
5693                                                                  return 2239;
5694                                                                }
5695                                                            }
5696                                                        }
5697                                                      else
5698                                                        {
5699                                                          if (((word >> 20) & 0x1) == 0)
5700                                                            {
5701                                                              if (((word >> 30) & 0x1) == 0)
5702                                                                {
5703                                                                  /* 33222222222211111111110000000000
5704                                                                     10987654321098765432109876543210
5705                                                                     000001x0xx001100100xxxxxxxxxxxxx
5706                                                                     srshr.  */
5707                                                                  return 2243;
5708                                                                }
5709                                                              else
5710                                                                {
5711                                                                  /* 33222222222211111111110000000000
5712                                                                     10987654321098765432109876543210
5713                                                                     010001x0xx001100100xxxxxxxxxxxxx
5714                                                                     sqshlr.  */
5715                                                                  return 2227;
5716                                                                }
5717                                                            }
5718                                                          else
5719                                                            {
5720                                                              /* 33222222222211111111110000000000
5721                                                                 10987654321098765432109876543210
5722                                                                 0x0001x0xx011100100xxxxxxxxxxxxx
5723                                                                 suqadd.  */
5724                                                              return 2263;
5725                                                            }
5726                                                        }
5727                                                    }
5728                                                }
5729                                              else
5730                                                {
5731                                                  if (((word >> 18) & 0x1) == 0)
5732                                                    {
5733                                                      if (((word >> 19) & 0x1) == 0)
5734                                                        {
5735                                                          if (((word >> 20) & 0x1) == 0)
5736                                                            {
5737                                                              /* 33222222222211111111110000000000
5738                                                                 10987654321098765432109876543210
5739                                                                 0x0001x0xx000010100xxxxxxxxxxxxx
5740                                                                 srshl.  */
5741                                                              return 2241;
5742                                                            }
5743                                                          else
5744                                                            {
5745                                                              /* 33222222222211111111110000000000
5746                                                                 10987654321098765432109876543210
5747                                                                 0x0001x0xx010010100xxxxxxxxxxxxx
5748                                                                 shsub.  */
5749                                                              return 2151;
5750                                                            }
5751                                                        }
5752                                                      else
5753                                                        {
5754                                                          if (((word >> 20) & 0x1) == 0)
5755                                                            {
5756                                                              /* 33222222222211111111110000000000
5757                                                                 10987654321098765432109876543210
5758                                                                 0x0001x0xx001010100xxxxxxxxxxxxx
5759                                                                 sqrshl.  */
5760                                                              return 2219;
5761                                                            }
5762                                                          else
5763                                                            {
5764                                                              /* 33222222222211111111110000000000
5765                                                                 10987654321098765432109876543210
5766                                                                 0x0001x0xx011010100xxxxxxxxxxxxx
5767                                                                 sqsub.  */
5768                                                              return 2233;
5769                                                            }
5770                                                        }
5771                                                    }
5772                                                  else
5773                                                    {
5774                                                      if (((word >> 19) & 0x1) == 0)
5775                                                        {
5776                                                          if (((word >> 20) & 0x1) == 0)
5777                                                            {
5778                                                              if (((word >> 30) & 0x1) == 0)
5779                                                                {
5780                                                                  /* 33222222222211111111110000000000
5781                                                                     10987654321098765432109876543210
5782                                                                     000001x0xx000110100xxxxxxxxxxxxx
5783                                                                     sqshl.  */
5784                                                                  return 2225;
5785                                                                }
5786                                                              else
5787                                                                {
5788                                                                  /* 33222222222211111111110000000000
5789                                                                     10987654321098765432109876543210
5790                                                                     010001x0xx000110100xxxxxxxxxxxxx
5791                                                                     srshlr.  */
5792                                                                  return 2242;
5793                                                                }
5794                                                            }
5795                                                          else
5796                                                            {
5797                                                              /* 33222222222211111111110000000000
5798                                                                 10987654321098765432109876543210
5799                                                                 0x0001x0xx010110100xxxxxxxxxxxxx
5800                                                                 shsubr.  */
5801                                                              return 2152;
5802                                                            }
5803                                                        }
5804                                                      else
5805                                                        {
5806                                                          if (((word >> 20) & 0x1) == 0)
5807                                                            {
5808                                                              /* 33222222222211111111110000000000
5809                                                                 10987654321098765432109876543210
5810                                                                 0x0001x0xx001110100xxxxxxxxxxxxx
5811                                                                 sqrshlr.  */
5812                                                              return 2220;
5813                                                            }
5814                                                          else
5815                                                            {
5816                                                              /* 33222222222211111111110000000000
5817                                                                 10987654321098765432109876543210
5818                                                                 0x0001x0xx011110100xxxxxxxxxxxxx
5819                                                                 sqsubr.  */
5820                                                              return 2234;
5821                                                            }
5822                                                        }
5823                                                    }
5824                                                }
5825                                            }
5826                                          else
5827                                            {
5828                                              if (((word >> 17) & 0x1) == 0)
5829                                                {
5830                                                  if (((word >> 18) & 0x1) == 0)
5831                                                    {
5832                                                      if (((word >> 19) & 0x1) == 0)
5833                                                        {
5834                                                          if (((word >> 20) & 0x1) == 0)
5835                                                            {
5836                                                              /* 33222222222211111111110000000000
5837                                                                 10987654321098765432109876543210
5838                                                                 0x0001x0xx000001100xxxxxxxxxxxxx
5839                                                                 lsr.  */
5840                                                              return 1751;
5841                                                            }
5842                                                          else
5843                                                            {
5844                                                              if (((word >> 30) & 0x1) == 0)
5845                                                                {
5846                                                                  /* 33222222222211111111110000000000
5847                                                                     10987654321098765432109876543210
5848                                                                     000001x0xx010001100xxxxxxxxxxxxx
5849                                                                     lsr.  */
5850                                                                  return 1749;
5851                                                                }
5852                                                              else
5853                                                                {
5854                                                                  /* 33222222222211111111110000000000
5855                                                                     10987654321098765432109876543210
5856                                                                     010001x0xx010001100xxxxxxxxxxxxx
5857                                                                     uhadd.  */
5858                                                                  return 2276;
5859                                                                }
5860                                                            }
5861                                                        }
5862                                                      else
5863                                                        {
5864                                                          if (((word >> 20) & 0x1) == 0)
5865                                                            {
5866                                                              /* 33222222222211111111110000000000
5867                                                                 10987654321098765432109876543210
5868                                                                 0x0001x0xx001001100xxxxxxxxxxxxx
5869                                                                 uqshl.  */
5870                                                              return 2306;
5871                                                            }
5872                                                          else
5873                                                            {
5874                                                              if (((word >> 30) & 0x1) == 0)
5875                                                                {
5876                                                                  /* 33222222222211111111110000000000
5877                                                                     10987654321098765432109876543210
5878                                                                     000001x0xx011001100xxxxxxxxxxxxx
5879                                                                     lsr.  */
5880                                                                  return 1750;
5881                                                                }
5882                                                              else
5883                                                                {
5884                                                                  /* 33222222222211111111110000000000
5885                                                                     10987654321098765432109876543210
5886                                                                     010001x0xx011001100xxxxxxxxxxxxx
5887                                                                     uqadd.  */
5888                                                                  return 2300;
5889                                                                }
5890                                                            }
5891                                                        }
5892                                                    }
5893                                                  else
5894                                                    {
5895                                                      if (((word >> 19) & 0x1) == 0)
5896                                                        {
5897                                                          if (((word >> 30) & 0x1) == 0)
5898                                                            {
5899                                                              /* 33222222222211111111110000000000
5900                                                                 10987654321098765432109876543210
5901                                                                 000001x0xx0x0101100xxxxxxxxxxxxx
5902                                                                 lsrr.  */
5903                                                              return 1752;
5904                                                            }
5905                                                          else
5906                                                            {
5907                                                              /* 33222222222211111111110000000000
5908                                                                 10987654321098765432109876543210
5909                                                                 010001x0xx0x0101100xxxxxxxxxxxxx
5910                                                                 urhadd.  */
5911                                                              return 2315;
5912                                                            }
5913                                                        }
5914                                                      else
5915                                                        {
5916                                                          if (((word >> 20) & 0x1) == 0)
5917                                                            {
5918                                                              if (((word >> 30) & 0x1) == 0)
5919                                                                {
5920                                                                  /* 33222222222211111111110000000000
5921                                                                     10987654321098765432109876543210
5922                                                                     000001x0xx001101100xxxxxxxxxxxxx
5923                                                                     urshr.  */
5924                                                                  return 2318;
5925                                                                }
5926                                                              else
5927                                                                {
5928                                                                  /* 33222222222211111111110000000000
5929                                                                     10987654321098765432109876543210
5930                                                                     010001x0xx001101100xxxxxxxxxxxxx
5931                                                                     uqshlr.  */
5932                                                                  return 2307;
5933                                                                }
5934                                                            }
5935                                                          else
5936                                                            {
5937                                                              /* 33222222222211111111110000000000
5938                                                                 10987654321098765432109876543210
5939                                                                 0x0001x0xx011101100xxxxxxxxxxxxx
5940                                                                 usqadd.  */
5941                                                              return 2323;
5942                                                            }
5943                                                        }
5944                                                    }
5945                                                }
5946                                              else
5947                                                {
5948                                                  if (((word >> 18) & 0x1) == 0)
5949                                                    {
5950                                                      if (((word >> 19) & 0x1) == 0)
5951                                                        {
5952                                                          if (((word >> 20) & 0x1) == 0)
5953                                                            {
5954                                                              if (((word >> 30) & 0x1) == 0)
5955                                                                {
5956                                                                  /* 33222222222211111111110000000000
5957                                                                     10987654321098765432109876543210
5958                                                                     000001x0xx000011100xxxxxxxxxxxxx
5959                                                                     lsl.  */
5960                                                                  return 1745;
5961                                                                }
5962                                                              else
5963                                                                {
5964                                                                  /* 33222222222211111111110000000000
5965                                                                     10987654321098765432109876543210
5966                                                                     010001x0xx000011100xxxxxxxxxxxxx
5967                                                                     urshl.  */
5968                                                                  return 2316;
5969                                                                }
5970                                                            }
5971                                                          else
5972                                                            {
5973                                                              if (((word >> 30) & 0x1) == 0)
5974                                                                {
5975                                                                  /* 33222222222211111111110000000000
5976                                                                     10987654321098765432109876543210
5977                                                                     000001x0xx010011100xxxxxxxxxxxxx
5978                                                                     lsl.  */
5979                                                                  return 1743;
5980                                                                }
5981                                                              else
5982                                                                {
5983                                                                  /* 33222222222211111111110000000000
5984                                                                     10987654321098765432109876543210
5985                                                                     010001x0xx010011100xxxxxxxxxxxxx
5986                                                                     uhsub.  */
5987                                                                  return 2277;
5988                                                                }
5989                                                            }
5990                                                        }
5991                                                      else
5992                                                        {
5993                                                          if (((word >> 20) & 0x1) == 0)
5994                                                            {
5995                                                              /* 33222222222211111111110000000000
5996                                                                 10987654321098765432109876543210
5997                                                                 0x0001x0xx001011100xxxxxxxxxxxxx
5998                                                                 uqrshl.  */
5999                                                              return 2301;
6000                                                            }
6001                                                          else
6002                                                            {
6003                                                              if (((word >> 30) & 0x1) == 0)
6004                                                                {
6005                                                                  /* 33222222222211111111110000000000
6006                                                                     10987654321098765432109876543210
6007                                                                     000001x0xx011011100xxxxxxxxxxxxx
6008                                                                     lsl.  */
6009                                                                  return 1744;
6010                                                                }
6011                                                              else
6012                                                                {
6013                                                                  /* 33222222222211111111110000000000
6014                                                                     10987654321098765432109876543210
6015                                                                     010001x0xx011011100xxxxxxxxxxxxx
6016                                                                     uqsub.  */
6017                                                                  return 2310;
6018                                                                }
6019                                                            }
6020                                                        }
6021                                                    }
6022                                                  else
6023                                                    {
6024                                                      if (((word >> 19) & 0x1) == 0)
6025                                                        {
6026                                                          if (((word >> 20) & 0x1) == 0)
6027                                                            {
6028                                                              if (((word >> 30) & 0x1) == 0)
6029                                                                {
6030                                                                  /* 33222222222211111111110000000000
6031                                                                     10987654321098765432109876543210
6032                                                                     000001x0xx000111100xxxxxxxxxxxxx
6033                                                                     uqshl.  */
6034                                                                  return 2305;
6035                                                                }
6036                                                              else
6037                                                                {
6038                                                                  /* 33222222222211111111110000000000
6039                                                                     10987654321098765432109876543210
6040                                                                     010001x0xx000111100xxxxxxxxxxxxx
6041                                                                     urshlr.  */
6042                                                                  return 2317;
6043                                                                }
6044                                                            }
6045                                                          else
6046                                                            {
6047                                                              if (((word >> 30) & 0x1) == 0)
6048                                                                {
6049                                                                  /* 33222222222211111111110000000000
6050                                                                     10987654321098765432109876543210
6051                                                                     000001x0xx010111100xxxxxxxxxxxxx
6052                                                                     lslr.  */
6053                                                                  return 1746;
6054                                                                }
6055                                                              else
6056                                                                {
6057                                                                  /* 33222222222211111111110000000000
6058                                                                     10987654321098765432109876543210
6059                                                                     010001x0xx010111100xxxxxxxxxxxxx
6060                                                                     uhsubr.  */
6061                                                                  return 2278;
6062                                                                }
6063                                                            }
6064                                                        }
6065                                                      else
6066                                                        {
6067                                                          if (((word >> 20) & 0x1) == 0)
6068                                                            {
6069                                                              if (((word >> 30) & 0x1) == 0)
6070                                                                {
6071                                                                  /* 33222222222211111111110000000000
6072                                                                     10987654321098765432109876543210
6073                                                                     000001x0xx001111100xxxxxxxxxxxxx
6074                                                                     sqshlu.  */
6075                                                                  return 2228;
6076                                                                }
6077                                                              else
6078                                                                {
6079                                                                  /* 33222222222211111111110000000000
6080                                                                     10987654321098765432109876543210
6081                                                                     010001x0xx001111100xxxxxxxxxxxxx
6082                                                                     uqrshlr.  */
6083                                                                  return 2302;
6084                                                                }
6085                                                            }
6086                                                          else
6087                                                            {
6088                                                              /* 33222222222211111111110000000000
6089                                                                 10987654321098765432109876543210
6090                                                                 0x0001x0xx011111100xxxxxxxxxxxxx
6091                                                                 uqsubr.  */
6092                                                              return 2311;
6093                                                            }
6094                                                        }
6095                                                    }
6096                                                }
6097                                            }
6098                                        }
6099                                      else
6100                                        {
6101                                          if (((word >> 10) & 0x1) == 0)
6102                                            {
6103                                              if (((word >> 12) & 0x1) == 0)
6104                                                {
6105                                                  if (((word >> 30) & 0x1) == 0)
6106                                                    {
6107                                                      /* 33222222222211111111110000000000
6108                                                         10987654321098765432109876543210
6109                                                         000001x0xx1xxxxx1000x0xxxxxxxxxx
6110                                                         asr.  */
6111                                                      return 1303;
6112                                                    }
6113                                                  else
6114                                                    {
6115                                                      if (((word >> 22) & 0x1) == 0)
6116                                                        {
6117                                                          /* 33222222222211111111110000000000
6118                                                             10987654321098765432109876543210
6119                                                             010001x0x01xxxxx1000x0xxxxxxxxxx
6120                                                             smlalb.  */
6121                                                          return 2156;
6122                                                        }
6123                                                      else
6124                                                        {
6125                                                          /* 33222222222211111111110000000000
6126                                                             10987654321098765432109876543210
6127                                                             010001x0x11xxxxx1000x0xxxxxxxxxx
6128                                                             smlalb.  */
6129                                                          return 2157;
6130                                                        }
6131                                                    }
6132                                                }
6133                                              else
6134                                                {
6135                                                  if (((word >> 30) & 0x1) == 0)
6136                                                    {
6137                                                      /* 33222222222211111111110000000000
6138                                                         10987654321098765432109876543210
6139                                                         000001x0xx1xxxxx1001x0xxxxxxxxxx
6140                                                         asr.  */
6141                                                      return 1304;
6142                                                    }
6143                                                  else
6144                                                    {
6145                                                      if (((word >> 22) & 0x1) == 0)
6146                                                        {
6147                                                          /* 33222222222211111111110000000000
6148                                                             10987654321098765432109876543210
6149                                                             010001x0x01xxxxx1001x0xxxxxxxxxx
6150                                                             umlalb.  */
6151                                                          return 2281;
6152                                                        }
6153                                                      else
6154                                                        {
6155                                                          /* 33222222222211111111110000000000
6156                                                             10987654321098765432109876543210
6157                                                             010001x0x11xxxxx1001x0xxxxxxxxxx
6158                                                             umlalb.  */
6159                                                          return 2282;
6160                                                        }
6161                                                    }
6162                                                }
6163                                            }
6164                                          else
6165                                            {
6166                                              if (((word >> 12) & 0x1) == 0)
6167                                                {
6168                                                  if (((word >> 30) & 0x1) == 0)
6169                                                    {
6170                                                      if (((word >> 11) & 0x1) == 0)
6171                                                        {
6172                                                          /* 33222222222211111111110000000000
6173                                                             10987654321098765432109876543210
6174                                                             000001x0xx1xxxxx100001xxxxxxxxxx
6175                                                             lsr.  */
6176                                                          return 1747;
6177                                                        }
6178                                                      else
6179                                                        {
6180                                                          /* 33222222222211111111110000000000
6181                                                             10987654321098765432109876543210
6182                                                             000001x0xx1xxxxx100011xxxxxxxxxx
6183                                                             lsl.  */
6184                                                          return 1741;
6185                                                        }
6186                                                    }
6187                                                  else
6188                                                    {
6189                                                      if (((word >> 22) & 0x1) == 0)
6190                                                        {
6191                                                          /* 33222222222211111111110000000000
6192                                                             10987654321098765432109876543210
6193                                                             010001x0x01xxxxx1000x1xxxxxxxxxx
6194                                                             smlalt.  */
6195                                                          return 2159;
6196                                                        }
6197                                                      else
6198                                                        {
6199                                                          /* 33222222222211111111110000000000
6200                                                             10987654321098765432109876543210
6201                                                             010001x0x11xxxxx1000x1xxxxxxxxxx
6202                                                             smlalt.  */
6203                                                          return 2160;
6204                                                        }
6205                                                    }
6206                                                }
6207                                              else
6208                                                {
6209                                                  if (((word >> 30) & 0x1) == 0)
6210                                                    {
6211                                                      if (((word >> 11) & 0x1) == 0)
6212                                                        {
6213                                                          /* 33222222222211111111110000000000
6214                                                             10987654321098765432109876543210
6215                                                             000001x0xx1xxxxx100101xxxxxxxxxx
6216                                                             lsr.  */
6217                                                          return 1748;
6218                                                        }
6219                                                      else
6220                                                        {
6221                                                          /* 33222222222211111111110000000000
6222                                                             10987654321098765432109876543210
6223                                                             000001x0xx1xxxxx100111xxxxxxxxxx
6224                                                             lsl.  */
6225                                                          return 1742;
6226                                                        }
6227                                                    }
6228                                                  else
6229                                                    {
6230                                                      if (((word >> 22) & 0x1) == 0)
6231                                                        {
6232                                                          /* 33222222222211111111110000000000
6233                                                             10987654321098765432109876543210
6234                                                             010001x0x01xxxxx1001x1xxxxxxxxxx
6235                                                             umlalt.  */
6236                                                          return 2284;
6237                                                        }
6238                                                      else
6239                                                        {
6240                                                          /* 33222222222211111111110000000000
6241                                                             10987654321098765432109876543210
6242                                                             010001x0x11xxxxx1001x1xxxxxxxxxx
6243                                                             umlalt.  */
6244                                                          return 2285;
6245                                                        }
6246                                                    }
6247                                                }
6248                                            }
6249                                        }
6250                                    }
6251                                  else
6252                                    {
6253                                      if (((word >> 22) & 0x1) == 0)
6254                                        {
6255                                          if (((word >> 21) & 0x1) == 0)
6256                                            {
6257                                              if (((word >> 23) & 0x1) == 0)
6258                                                {
6259                                                  /* 33222222222211111111110000000000
6260                                                     10987654321098765432109876543210
6261                                                     1x0001x0000xxxxx100xxxxxxxxxxxxx
6262                                                     ldnt1sb.  */
6263                                                  return 2108;
6264                                                }
6265                                              else
6266                                                {
6267                                                  /* 33222222222211111111110000000000
6268                                                     10987654321098765432109876543210
6269                                                     1x0001x0100xxxxx100xxxxxxxxxxxxx
6270                                                     ldnt1sh.  */
6271                                                  return 2109;
6272                                                }
6273                                            }
6274                                          else
6275                                            {
6276                                              if (((word >> 23) & 0x1) == 0)
6277                                                {
6278                                                  if (((word >> 30) & 0x1) == 0)
6279                                                    {
6280                                                      /* 33222222222211111111110000000000
6281                                                         10987654321098765432109876543210
6282                                                         100001x0001xxxxx100xxxxxxxxxxxxx
6283                                                         ld1sb.  */
6284                                                      return 1579;
6285                                                    }
6286                                                  else
6287                                                    {
6288                                                      /* 33222222222211111111110000000000
6289                                                         10987654321098765432109876543210
6290                                                         110001x0001xxxxx100xxxxxxxxxxxxx
6291                                                         ld1sb.  */
6292                                                      return 1583;
6293                                                    }
6294                                                }
6295                                              else
6296                                                {
6297                                                  if (((word >> 30) & 0x1) == 0)
6298                                                    {
6299                                                      /* 33222222222211111111110000000000
6300                                                         10987654321098765432109876543210
6301                                                         100001x0101xxxxx100xxxxxxxxxxxxx
6302                                                         ld1sh.  */
6303                                                      return 1592;
6304                                                    }
6305                                                  else
6306                                                    {
6307                                                      /* 33222222222211111111110000000000
6308                                                         10987654321098765432109876543210
6309                                                         110001x0101xxxxx100xxxxxxxxxxxxx
6310                                                         ld1sh.  */
6311                                                      return 1595;
6312                                                    }
6313                                                }
6314                                            }
6315                                        }
6316                                      else
6317                                        {
6318                                          if (((word >> 23) & 0x1) == 0)
6319                                            {
6320                                              if (((word >> 30) & 0x1) == 0)
6321                                                {
6322                                                  /* 33222222222211111111110000000000
6323                                                     10987654321098765432109876543210
6324                                                     100001x001xxxxxx100xxxxxxxxxxxxx
6325                                                     ld1rb.  */
6326                                                  return 1549;
6327                                                }
6328                                              else
6329                                                {
6330                                                  if (((word >> 21) & 0x1) == 0)
6331                                                    {
6332                                                      /* 33222222222211111111110000000000
6333                                                         10987654321098765432109876543210
6334                                                         110001x0010xxxxx100xxxxxxxxxxxxx
6335                                                         ld1sb.  */
6336                                                      return 1578;
6337                                                    }
6338                                                  else
6339                                                    {
6340                                                      /* 33222222222211111111110000000000
6341                                                         10987654321098765432109876543210
6342                                                         110001x0011xxxxx100xxxxxxxxxxxxx
6343                                                         prfb.  */
6344                                                      return 1781;
6345                                                    }
6346                                                }
6347                                            }
6348                                          else
6349                                            {
6350                                              if (((word >> 30) & 0x1) == 0)
6351                                                {
6352                                                  /* 33222222222211111111110000000000
6353                                                     10987654321098765432109876543210
6354                                                     100001x011xxxxxx100xxxxxxxxxxxxx
6355                                                     ld1rsw.  */
6356                                                  return 1570;
6357                                                }
6358                                              else
6359                                                {
6360                                                  if (((word >> 21) & 0x1) == 0)
6361                                                    {
6362                                                      /* 33222222222211111111110000000000
6363                                                         10987654321098765432109876543210
6364                                                         110001x0110xxxxx100xxxxxxxxxxxxx
6365                                                         ld1sh.  */
6366                                                      return 1590;
6367                                                    }
6368                                                  else
6369                                                    {
6370                                                      /* 33222222222211111111110000000000
6371                                                         10987654321098765432109876543210
6372                                                         110001x0111xxxxx100xxxxxxxxxxxxx
6373                                                         ld1sh.  */
6374                                                      return 1591;
6375                                                    }
6376                                                }
6377                                            }
6378                                        }
6379                                    }
6380                                }
6381                            }
6382                          else
6383                            {
6384                              if (((word >> 15) & 0x1) == 0)
6385                                {
6386                                  if (((word >> 21) & 0x1) == 0)
6387                                    {
6388                                      if (((word >> 30) & 0x1) == 0)
6389                                        {
6390                                          if (((word >> 31) & 0x1) == 0)
6391                                            {
6392                                              /* 33222222222211111111110000000000
6393                                                 10987654321098765432109876543210
6394                                                 000001x0xx0xxxxx010xxxxxxxxxxxxx
6395                                                 mla.  */
6396                                              return 1754;
6397                                            }
6398                                          else
6399                                            {
6400                                              if (((word >> 23) & 0x1) == 0)
6401                                                {
6402                                                  /* 33222222222211111111110000000000
6403                                                     10987654321098765432109876543210
6404                                                     100001x00x0xxxxx010xxxxxxxxxxxxx
6405                                                     ld1b.  */
6406                                                  return 1515;
6407                                                }
6408                                              else
6409                                                {
6410                                                  /* 33222222222211111111110000000000
6411                                                     10987654321098765432109876543210
6412                                                     100001x01x0xxxxx010xxxxxxxxxxxxx
6413                                                     ld1h.  */
6414                                                  return 1535;
6415                                                }
6416                                            }
6417                                        }
6418                                      else
6419                                        {
6420                                          if (((word >> 31) & 0x1) == 0)
6421                                            {
6422                                              if (((word >> 10) & 0x1) == 0)
6423                                                {
6424                                                  if (((word >> 11) & 0x1) == 0)
6425                                                    {
6426                                                      if (((word >> 12) & 0x1) == 0)
6427                                                        {
6428                                                          /* 33222222222211111111110000000000
6429                                                             10987654321098765432109876543210
6430                                                             010001x0xx0xxxxx010000xxxxxxxxxx
6431                                                             smlalb.  */
6432                                                          return 2158;
6433                                                        }
6434                                                      else
6435                                                        {
6436                                                          /* 33222222222211111111110000000000
6437                                                             10987654321098765432109876543210
6438                                                             010001x0xx0xxxxx010100xxxxxxxxxx
6439                                                             smlslb.  */
6440                                                          return 2164;
6441                                                        }
6442                                                    }
6443                                                  else
6444                                                    {
6445                                                      if (((word >> 12) & 0x1) == 0)
6446                                                        {
6447                                                          /* 33222222222211111111110000000000
6448                                                             10987654321098765432109876543210
6449                                                             010001x0xx0xxxxx010010xxxxxxxxxx
6450                                                             umlalb.  */
6451                                                          return 2283;
6452                                                        }
6453                                                      else
6454                                                        {
6455                                                          /* 33222222222211111111110000000000
6456                                                             10987654321098765432109876543210
6457                                                             010001x0xx0xxxxx010110xxxxxxxxxx
6458                                                             umlslb.  */
6459                                                          return 2289;
6460                                                        }
6461                                                    }
6462                                                }
6463                                              else
6464                                                {
6465                                                  if (((word >> 11) & 0x1) == 0)
6466                                                    {
6467                                                      if (((word >> 12) & 0x1) == 0)
6468                                                        {
6469                                                          /* 33222222222211111111110000000000
6470                                                             10987654321098765432109876543210
6471                                                             010001x0xx0xxxxx010001xxxxxxxxxx
6472                                                             smlalt.  */
6473                                                          return 2161;
6474                                                        }
6475                                                      else
6476                                                        {
6477                                                          /* 33222222222211111111110000000000
6478                                                             10987654321098765432109876543210
6479                                                             010001x0xx0xxxxx010101xxxxxxxxxx
6480                                                             smlslt.  */
6481                                                          return 2167;
6482                                                        }
6483                                                    }
6484                                                  else
6485                                                    {
6486                                                      if (((word >> 12) & 0x1) == 0)
6487                                                        {
6488                                                          /* 33222222222211111111110000000000
6489                                                             10987654321098765432109876543210
6490                                                             010001x0xx0xxxxx010011xxxxxxxxxx
6491                                                             umlalt.  */
6492                                                          return 2286;
6493                                                        }
6494                                                      else
6495                                                        {
6496                                                          /* 33222222222211111111110000000000
6497                                                             10987654321098765432109876543210
6498                                                             010001x0xx0xxxxx010111xxxxxxxxxx
6499                                                             umlslt.  */
6500                                                          return 2292;
6501                                                        }
6502                                                    }
6503                                                }
6504                                            }
6505                                          else
6506                                            {
6507                                              if (((word >> 23) & 0x1) == 0)
6508                                                {
6509                                                  /* 33222222222211111111110000000000
6510                                                     10987654321098765432109876543210
6511                                                     110001x00x0xxxxx010xxxxxxxxxxxxx
6512                                                     ld1b.  */
6513                                                  return 1520;
6514                                                }
6515                                              else
6516                                                {
6517                                                  /* 33222222222211111111110000000000
6518                                                     10987654321098765432109876543210
6519                                                     110001x01x0xxxxx010xxxxxxxxxxxxx
6520                                                     ld1h.  */
6521                                                  return 1540;
6522                                                }
6523                                            }
6524                                        }
6525                                    }
6526                                  else
6527                                    {
6528                                      if (((word >> 30) & 0x1) == 0)
6529                                        {
6530                                          if (((word >> 31) & 0x1) == 0)
6531                                            {
6532                                              if (((word >> 11) & 0x1) == 0)
6533                                                {
6534                                                  if (((word >> 12) & 0x1) == 0)
6535                                                    {
6536                                                      if (((word >> 10) & 0x1) == 0)
6537                                                        {
6538                                                          /* 33222222222211111111110000000000
6539                                                             10987654321098765432109876543210
6540                                                             000001x0xx1xxxxx010000xxxxxxxxxx
6541                                                             index.  */
6542                                                          return 1506;
6543                                                        }
6544                                                      else
6545                                                        {
6546                                                          /* 33222222222211111111110000000000
6547                                                             10987654321098765432109876543210
6548                                                             000001x0xx1xxxxx010001xxxxxxxxxx
6549                                                             index.  */
6550                                                          return 1507;
6551                                                        }
6552                                                    }
6553                                                  else
6554                                                    {
6555                                                      if (((word >> 22) & 0x1) == 0)
6556                                                        {
6557                                                          if (((word >> 23) & 0x1) == 0)
6558                                                            {
6559                                                              /* 33222222222211111111110000000000
6560                                                                 10987654321098765432109876543210
6561                                                                 000001x0001xxxxx01010xxxxxxxxxxx
6562                                                                 addvl.  */
6563                                                              return 1293;
6564                                                            }
6565                                                          else
6566                                                            {
6567                                                              /* 33222222222211111111110000000000
6568                                                                 10987654321098765432109876543210
6569                                                                 000001x0101xxxxx01010xxxxxxxxxxx
6570                                                                 rdvl.  */
6571                                                              return 1815;
6572                                                            }
6573                                                        }
6574                                                      else
6575                                                        {
6576                                                          /* 33222222222211111111110000000000
6577                                                             10987654321098765432109876543210
6578                                                             000001x0x11xxxxx01010xxxxxxxxxxx
6579                                                             addpl.  */
6580                                                          return 1292;
6581                                                        }
6582                                                    }
6583                                                }
6584                                              else
6585                                                {
6586                                                  if (((word >> 12) & 0x1) == 0)
6587                                                    {
6588                                                      if (((word >> 10) & 0x1) == 0)
6589                                                        {
6590                                                          /* 33222222222211111111110000000000
6591                                                             10987654321098765432109876543210
6592                                                             000001x0xx1xxxxx010010xxxxxxxxxx
6593                                                             index.  */
6594                                                          return 1508;
6595                                                        }
6596                                                      else
6597                                                        {
6598                                                          /* 33222222222211111111110000000000
6599                                                             10987654321098765432109876543210
6600                                                             000001x0xx1xxxxx010011xxxxxxxxxx
6601                                                             index.  */
6602                                                          return 1505;
6603                                                        }
6604                                                    }
6605                                                  else
6606                                                    {
6607                                                      if (((word >> 22) & 0x1) == 0)
6608                                                        {
6609                                                          if (((word >> 23) & 0x1) == 0)
6610                                                            {
6611                                                              /* 33222222222211111111110000000000
6612                                                                 10987654321098765432109876543210
6613                                                                 000001x0001xxxxx01011xxxxxxxxxxx
6614                                                                 addsvl.  */
6615                                                              return 2355;
6616                                                            }
6617                                                          else
6618                                                            {
6619                                                              /* 33222222222211111111110000000000
6620                                                                 10987654321098765432109876543210
6621                                                                 000001x0101xxxxx01011xxxxxxxxxxx
6622                                                                 rdsvl.  */
6623                                                              return 2366;
6624                                                            }
6625                                                        }
6626                                                      else
6627                                                        {
6628                                                          /* 33222222222211111111110000000000
6629                                                             10987654321098765432109876543210
6630                                                             000001x0x11xxxxx01011xxxxxxxxxxx
6631                                                             addspl.  */
6632                                                          return 2354;
6633                                                        }
6634                                                    }
6635                                                }
6636                                            }
6637                                          else
6638                                            {
6639                                              if (((word >> 23) & 0x1) == 0)
6640                                                {
6641                                                  /* 33222222222211111111110000000000
6642                                                     10987654321098765432109876543210
6643                                                     100001x00x1xxxxx010xxxxxxxxxxxxx
6644                                                     prfw.  */
6645                                                  return 1799;
6646                                                }
6647                                              else
6648                                                {
6649                                                  /* 33222222222211111111110000000000
6650                                                     10987654321098765432109876543210
6651                                                     100001x01x1xxxxx010xxxxxxxxxxxxx
6652                                                     ld1h.  */
6653                                                  return 1536;
6654                                                }
6655                                            }
6656                                        }
6657                                      else
6658                                        {
6659                                          if (((word >> 23) & 0x1) == 0)
6660                                            {
6661                                              /* 33222222222211111111110000000000
6662                                                 10987654321098765432109876543210
6663                                                 x10001x00x1xxxxx010xxxxxxxxxxxxx
6664                                                 prfw.  */
6665                                              return 1801;
6666                                            }
6667                                          else
6668                                            {
6669                                              if (((word >> 31) & 0x1) == 0)
6670                                                {
6671                                                  if (((word >> 22) & 0x1) == 0)
6672                                                    {
6673                                                      /* 33222222222211111111110000000000
6674                                                         10987654321098765432109876543210
6675                                                         010001x0101xxxxx010xxxxxxxxxxxxx
6676                                                         cdot.  */
6677                                                      return 2073;
6678                                                    }
6679                                                  else
6680                                                    {
6681                                                      /* 33222222222211111111110000000000
6682                                                         10987654321098765432109876543210
6683                                                         010001x0111xxxxx010xxxxxxxxxxxxx
6684                                                         cdot.  */
6685                                                      return 2072;
6686                                                    }
6687                                                }
6688                                              else
6689                                                {
6690                                                  /* 33222222222211111111110000000000
6691                                                     10987654321098765432109876543210
6692                                                     110001x01x1xxxxx010xxxxxxxxxxxxx
6693                                                     ld1h.  */
6694                                                  return 1541;
6695                                                }
6696                                            }
6697                                        }
6698                                    }
6699                                }
6700                              else
6701                                {
6702                                  if (((word >> 30) & 0x1) == 0)
6703                                    {
6704                                      if (((word >> 31) & 0x1) == 0)
6705                                        {
6706                                          if (((word >> 21) & 0x1) == 0)
6707                                            {
6708                                              /* 33222222222211111111110000000000
6709                                                 10987654321098765432109876543210
6710                                                 000001x0xx0xxxxx110xxxxxxxxxxxxx
6711                                                 mad.  */
6712                                              return 1753;
6713                                            }
6714                                          else
6715                                            {
6716                                              if (((word >> 10) & 0x1) == 0)
6717                                                {
6718                                                  if (((word >> 11) & 0x1) == 0)
6719                                                    {
6720                                                      if (((word >> 20) & 0x1) == 0)
6721                                                        {
6722                                                          if (((word >> 22) & 0x1) == 0)
6723                                                            {
6724                                                              /* 33222222222211111111110000000000
6725                                                                 10987654321098765432109876543210
6726                                                                 000001x0x010xxxx110x00xxxxxxxxxx
6727                                                                 sqincw.  */
6728                                                              return 1873;
6729                                                            }
6730                                                          else
6731                                                            {
6732                                                              if (((word >> 23) & 0x1) == 0)
6733                                                                {
6734                                                                  /* 33222222222211111111110000000000
6735                                                                     10987654321098765432109876543210
6736                                                                     000001x00110xxxx110x00xxxxxxxxxx
6737                                                                     sqinch.  */
6738                                                                  return 1867;
6739                                                                }
6740                                                              else
6741                                                                {
6742                                                                  /* 33222222222211111111110000000000
6743                                                                     10987654321098765432109876543210
6744                                                                     000001x01110xxxx110x00xxxxxxxxxx
6745                                                                     sqincd.  */
6746                                                                  return 1864;
6747                                                                }
6748                                                            }
6749                                                        }
6750                                                      else
6751                                                        {
6752                                                          if (((word >> 22) & 0x1) == 0)
6753                                                            {
6754                                                              /* 33222222222211111111110000000000
6755                                                                 10987654321098765432109876543210
6756                                                                 000001x0x011xxxx110x00xxxxxxxxxx
6757                                                                 incw.  */
6758                                                              return 1503;
6759                                                            }
6760                                                          else
6761                                                            {
6762                                                              if (((word >> 23) & 0x1) == 0)
6763                                                                {
6764                                                                  /* 33222222222211111111110000000000
6765                                                                     10987654321098765432109876543210
6766                                                                     000001x00111xxxx110x00xxxxxxxxxx
6767                                                                     inch.  */
6768                                                                  return 1499;
6769                                                                }
6770                                                              else
6771                                                                {
6772                                                                  /* 33222222222211111111110000000000
6773                                                                     10987654321098765432109876543210
6774                                                                     000001x01111xxxx110x00xxxxxxxxxx
6775                                                                     incd.  */
6776                                                                  return 1497;
6777                                                                }
6778                                                            }
6779                                                        }
6780                                                    }
6781                                                  else
6782                                                    {
6783                                                      if (((word >> 22) & 0x1) == 0)
6784                                                        {
6785                                                          /* 33222222222211111111110000000000
6786                                                             10987654321098765432109876543210
6787                                                             000001x0x01xxxxx110x10xxxxxxxxxx
6788                                                             sqdecw.  */
6789                                                          return 1859;
6790                                                        }
6791                                                      else
6792                                                        {
6793                                                          if (((word >> 23) & 0x1) == 0)
6794                                                            {
6795                                                              /* 33222222222211111111110000000000
6796                                                                 10987654321098765432109876543210
6797                                                                 000001x0011xxxxx110x10xxxxxxxxxx
6798                                                                 sqdech.  */
6799                                                              return 1853;
6800                                                            }
6801                                                          else
6802                                                            {
6803                                                              /* 33222222222211111111110000000000
6804                                                                 10987654321098765432109876543210
6805                                                                 000001x0111xxxxx110x10xxxxxxxxxx
6806                                                                 sqdecd.  */
6807                                                              return 1850;
6808                                                            }
6809                                                        }
6810                                                    }
6811                                                }
6812                                              else
6813                                                {
6814                                                  if (((word >> 11) & 0x1) == 0)
6815                                                    {
6816                                                      if (((word >> 20) & 0x1) == 0)
6817                                                        {
6818                                                          if (((word >> 22) & 0x1) == 0)
6819                                                            {
6820                                                              /* 33222222222211111111110000000000
6821                                                                 10987654321098765432109876543210
6822                                                                 000001x0x010xxxx110x01xxxxxxxxxx
6823                                                                 uqincw.  */
6824                                                              return 2021;
6825                                                            }
6826                                                          else
6827                                                            {
6828                                                              if (((word >> 23) & 0x1) == 0)
6829                                                                {
6830                                                                  /* 33222222222211111111110000000000
6831                                                                     10987654321098765432109876543210
6832                                                                     000001x00110xxxx110x01xxxxxxxxxx
6833                                                                     uqinch.  */
6834                                                                  return 2015;
6835                                                                }
6836                                                              else
6837                                                                {
6838                                                                  /* 33222222222211111111110000000000
6839                                                                     10987654321098765432109876543210
6840                                                                     000001x01110xxxx110x01xxxxxxxxxx
6841                                                                     uqincd.  */
6842                                                                  return 2012;
6843                                                                }
6844                                                            }
6845                                                        }
6846                                                      else
6847                                                        {
6848                                                          if (((word >> 22) & 0x1) == 0)
6849                                                            {
6850                                                              /* 33222222222211111111110000000000
6851                                                                 10987654321098765432109876543210
6852                                                                 000001x0x011xxxx110x01xxxxxxxxxx
6853                                                                 decw.  */
6854                                                              return 1378;
6855                                                            }
6856                                                          else
6857                                                            {
6858                                                              if (((word >> 23) & 0x1) == 0)
6859                                                                {
6860                                                                  /* 33222222222211111111110000000000
6861                                                                     10987654321098765432109876543210
6862                                                                     000001x00111xxxx110x01xxxxxxxxxx
6863                                                                     dech.  */
6864                                                                  return 1374;
6865                                                                }
6866                                                              else
6867                                                                {
6868                                                                  /* 33222222222211111111110000000000
6869                                                                     10987654321098765432109876543210
6870                                                                     000001x01111xxxx110x01xxxxxxxxxx
6871                                                                     decd.  */
6872                                                                  return 1372;
6873                                                                }
6874                                                            }
6875                                                        }
6876                                                    }
6877                                                  else
6878                                                    {
6879                                                      if (((word >> 22) & 0x1) == 0)
6880                                                        {
6881                                                          /* 33222222222211111111110000000000
6882                                                             10987654321098765432109876543210
6883                                                             000001x0x01xxxxx110x11xxxxxxxxxx
6884                                                             uqdecw.  */
6885                                                          return 2007;
6886                                                        }
6887                                                      else
6888                                                        {
6889                                                          if (((word >> 23) & 0x1) == 0)
6890                                                            {
6891                                                              /* 33222222222211111111110000000000
6892                                                                 10987654321098765432109876543210
6893                                                                 000001x0011xxxxx110x11xxxxxxxxxx
6894                                                                 uqdech.  */
6895                                                              return 2001;
6896                                                            }
6897                                                          else
6898                                                            {
6899                                                              /* 33222222222211111111110000000000
6900                                                                 10987654321098765432109876543210
6901                                                                 000001x0111xxxxx110x11xxxxxxxxxx
6902                                                                 uqdecd.  */
6903                                                              return 1998;
6904                                                            }
6905                                                        }
6906                                                    }
6907                                                }
6908                                            }
6909                                        }
6910                                      else
6911                                        {
6912                                          if (((word >> 22) & 0x1) == 0)
6913                                            {
6914                                              if (((word >> 21) & 0x1) == 0)
6915                                                {
6916                                                  if (((word >> 23) & 0x1) == 0)
6917                                                    {
6918                                                      /* 33222222222211111111110000000000
6919                                                         10987654321098765432109876543210
6920                                                         100001x0000xxxxx110xxxxxxxxxxxxx
6921                                                         prfb.  */
6922                                                      return 1778;
6923                                                    }
6924                                                  else
6925                                                    {
6926                                                      /* 33222222222211111111110000000000
6927                                                         10987654321098765432109876543210
6928                                                         100001x0100xxxxx110xxxxxxxxxxxxx
6929                                                         prfh.  */
6930                                                      return 1793;
6931                                                    }
6932                                                }
6933                                              else
6934                                                {
6935                                                  if (((word >> 23) & 0x1) == 0)
6936                                                    {
6937                                                      /* 33222222222211111111110000000000
6938                                                         10987654321098765432109876543210
6939                                                         100001x0001xxxxx110xxxxxxxxxxxxx
6940                                                         ld1b.  */
6941                                                      return 1522;
6942                                                    }
6943                                                  else
6944                                                    {
6945                                                      /* 33222222222211111111110000000000
6946                                                         10987654321098765432109876543210
6947                                                         100001x0101xxxxx110xxxxxxxxxxxxx
6948                                                         ld1h.  */
6949                                                      return 1544;
6950                                                    }
6951                                                }
6952                                            }
6953                                          else
6954                                            {
6955                                              if (((word >> 23) & 0x1) == 0)
6956                                                {
6957                                                  /* 33222222222211111111110000000000
6958                                                     10987654321098765432109876543210
6959                                                     100001x001xxxxxx110xxxxxxxxxxxxx
6960                                                     ld1rb.  */
6961                                                  return 1551;
6962                                                }
6963                                              else
6964                                                {
6965                                                  /* 33222222222211111111110000000000
6966                                                     10987654321098765432109876543210
6967                                                     100001x011xxxxxx110xxxxxxxxxxxxx
6968                                                     ld1rh.  */
6969                                                  return 1555;
6970                                                }
6971                                            }
6972                                        }
6973                                    }
6974                                  else
6975                                    {
6976                                      if (((word >> 21) & 0x1) == 0)
6977                                        {
6978                                          if (((word >> 31) & 0x1) == 0)
6979                                            {
6980                                              if (((word >> 10) & 0x1) == 0)
6981                                                {
6982                                                  /* 33222222222211111111110000000000
6983                                                     10987654321098765432109876543210
6984                                                     010001x0xx0xxxxx110xx0xxxxxxxxxx
6985                                                     sclamp.  */
6986                                                  return 2411;
6987                                                }
6988                                              else
6989                                                {
6990                                                  /* 33222222222211111111110000000000
6991                                                     10987654321098765432109876543210
6992                                                     010001x0xx0xxxxx110xx1xxxxxxxxxx
6993                                                     uclamp.  */
6994                                                  return 2412;
6995                                                }
6996                                            }
6997                                          else
6998                                            {
6999                                              if (((word >> 22) & 0x1) == 0)
7000                                                {
7001                                                  if (((word >> 23) & 0x1) == 0)
7002                                                    {
7003                                                      /* 33222222222211111111110000000000
7004                                                         10987654321098765432109876543210
7005                                                         110001x0000xxxxx110xxxxxxxxxxxxx
7006                                                         ldnt1b.  */
7007                                                      return 2104;
7008                                                    }
7009                                                  else
7010                                                    {
7011                                                      /* 33222222222211111111110000000000
7012                                                         10987654321098765432109876543210
7013                                                         110001x0100xxxxx110xxxxxxxxxxxxx
7014                                                         ldnt1h.  */
7015                                                      return 2107;
7016                                                    }
7017                                                }
7018                                              else
7019                                                {
7020                                                  if (((word >> 23) & 0x1) == 0)
7021                                                    {
7022                                                      /* 33222222222211111111110000000000
7023                                                         10987654321098765432109876543210
7024                                                         110001x0010xxxxx110xxxxxxxxxxxxx
7025                                                         ld1b.  */
7026                                                      return 1521;
7027                                                    }
7028                                                  else
7029                                                    {
7030                                                      /* 33222222222211111111110000000000
7031                                                         10987654321098765432109876543210
7032                                                         110001x0110xxxxx110xxxxxxxxxxxxx
7033                                                         ld1h.  */
7034                                                      return 1542;
7035                                                    }
7036                                                }
7037                                            }
7038                                        }
7039                                      else
7040                                        {
7041                                          if (((word >> 22) & 0x1) == 0)
7042                                            {
7043                                              if (((word >> 23) & 0x1) == 0)
7044                                                {
7045                                                  /* 33222222222211111111110000000000
7046                                                     10987654321098765432109876543210
7047                                                     x10001x0001xxxxx110xxxxxxxxxxxxx
7048                                                     ld1b.  */
7049                                                  return 1527;
7050                                                }
7051                                              else
7052                                                {
7053                                                  if (((word >> 31) & 0x1) == 0)
7054                                                    {
7055                                                      if (((word >> 10) & 0x1) == 0)
7056                                                        {
7057                                                          if (((word >> 12) & 0x1) == 0)
7058                                                            {
7059                                                              /* 33222222222211111111110000000000
7060                                                                 10987654321098765432109876543210
7061                                                                 010001x0101xxxxx1100x0xxxxxxxxxx
7062                                                                 smullb.  */
7063                                                              return 2169;
7064                                                            }
7065                                                          else
7066                                                            {
7067                                                              /* 33222222222211111111110000000000
7068                                                                 10987654321098765432109876543210
7069                                                                 010001x0101xxxxx1101x0xxxxxxxxxx
7070                                                                 umullb.  */
7071                                                              return 2294;
7072                                                            }
7073                                                        }
7074                                                      else
7075                                                        {
7076                                                          if (((word >> 12) & 0x1) == 0)
7077                                                            {
7078                                                              /* 33222222222211111111110000000000
7079                                                                 10987654321098765432109876543210
7080                                                                 010001x0101xxxxx1100x1xxxxxxxxxx
7081                                                                 smullt.  */
7082                                                              return 2172;
7083                                                            }
7084                                                          else
7085                                                            {
7086                                                              /* 33222222222211111111110000000000
7087                                                                 10987654321098765432109876543210
7088                                                                 010001x0101xxxxx1101x1xxxxxxxxxx
7089                                                                 umullt.  */
7090                                                              return 2297;
7091                                                            }
7092                                                        }
7093                                                    }
7094                                                  else
7095                                                    {
7096                                                      /* 33222222222211111111110000000000
7097                                                         10987654321098765432109876543210
7098                                                         110001x0101xxxxx110xxxxxxxxxxxxx
7099                                                         ld1h.  */
7100                                                      return 1548;
7101                                                    }
7102                                                }
7103                                            }
7104                                          else
7105                                            {
7106                                              if (((word >> 23) & 0x1) == 0)
7107                                                {
7108                                                  /* 33222222222211111111110000000000
7109                                                     10987654321098765432109876543210
7110                                                     x10001x0011xxxxx110xxxxxxxxxxxxx
7111                                                     prfw.  */
7112                                                  return 1802;
7113                                                }
7114                                              else
7115                                                {
7116                                                  if (((word >> 31) & 0x1) == 0)
7117                                                    {
7118                                                      if (((word >> 10) & 0x1) == 0)
7119                                                        {
7120                                                          if (((word >> 12) & 0x1) == 0)
7121                                                            {
7122                                                              /* 33222222222211111111110000000000
7123                                                                 10987654321098765432109876543210
7124                                                                 010001x0111xxxxx1100x0xxxxxxxxxx
7125                                                                 smullb.  */
7126                                                              return 2170;
7127                                                            }
7128                                                          else
7129                                                            {
7130                                                              /* 33222222222211111111110000000000
7131                                                                 10987654321098765432109876543210
7132                                                                 010001x0111xxxxx1101x0xxxxxxxxxx
7133                                                                 umullb.  */
7134                                                              return 2295;
7135                                                            }
7136                                                        }
7137                                                      else
7138                                                        {
7139                                                          if (((word >> 12) & 0x1) == 0)
7140                                                            {
7141                                                              /* 33222222222211111111110000000000
7142                                                                 10987654321098765432109876543210
7143                                                                 010001x0111xxxxx1100x1xxxxxxxxxx
7144                                                                 smullt.  */
7145                                                              return 2173;
7146                                                            }
7147                                                          else
7148                                                            {
7149                                                              /* 33222222222211111111110000000000
7150                                                                 10987654321098765432109876543210
7151                                                                 010001x0111xxxxx1101x1xxxxxxxxxx
7152                                                                 umullt.  */
7153                                                              return 2298;
7154                                                            }
7155                                                        }
7156                                                    }
7157                                                  else
7158                                                    {
7159                                                      /* 33222222222211111111110000000000
7160                                                         10987654321098765432109876543210
7161                                                         110001x0111xxxxx110xxxxxxxxxxxxx
7162                                                         ld1h.  */
7163                                                      return 1543;
7164                                                    }
7165                                                }
7166                                            }
7167                                        }
7168                                    }
7169                                }
7170                            }
7171                        }
7172                      else
7173                        {
7174                          if (((word >> 14) & 0x1) == 0)
7175                            {
7176                              if (((word >> 15) & 0x1) == 0)
7177                                {
7178                                  if (((word >> 21) & 0x1) == 0)
7179                                    {
7180                                      if (((word >> 30) & 0x1) == 0)
7181                                        {
7182                                          if (((word >> 31) & 0x1) == 0)
7183                                            {
7184                                              if (((word >> 17) & 0x1) == 0)
7185                                                {
7186                                                  if (((word >> 19) & 0x1) == 0)
7187                                                    {
7188                                                      if (((word >> 20) & 0x1) == 0)
7189                                                        {
7190                                                          if (((word >> 16) & 0x1) == 0)
7191                                                            {
7192                                                              /* 33222222222211111111110000000000
7193                                                                 10987654321098765432109876543210
7194                                                                 000001x0xx000x00001xxxxxxxxxxxxx
7195                                                                 saddv.  */
7196                                                              return 1822;
7197                                                            }
7198                                                          else
7199                                                            {
7200                                                              /* 33222222222211111111110000000000
7201                                                                 10987654321098765432109876543210
7202                                                                 000001x0xx000x01001xxxxxxxxxxxxx
7203                                                                 uaddv.  */
7204                                                              return 1974;
7205                                                            }
7206                                                        }
7207                                                      else
7208                                                        {
7209                                                          /* 33222222222211111111110000000000
7210                                                             10987654321098765432109876543210
7211                                                             000001x0xx010x0x001xxxxxxxxxxxxx
7212                                                             movprfx.  */
7213                                                          return 1757;
7214                                                        }
7215                                                    }
7216                                                  else
7217                                                    {
7218                                                      if (((word >> 16) & 0x1) == 0)
7219                                                        {
7220                                                          if (((word >> 20) & 0x1) == 0)
7221                                                            {
7222                                                              /* 33222222222211111111110000000000
7223                                                                 10987654321098765432109876543210
7224                                                                 000001x0xx001x00001xxxxxxxxxxxxx
7225                                                                 smaxv.  */
7226                                                              return 1840;
7227                                                            }
7228                                                          else
7229                                                            {
7230                                                              /* 33222222222211111111110000000000
7231                                                                 10987654321098765432109876543210
7232                                                                 000001x0xx011x00001xxxxxxxxxxxxx
7233                                                                 orv.  */
7234                                                              return 1774;
7235                                                            }
7236                                                        }
7237                                                      else
7238                                                        {
7239                                                          if (((word >> 20) & 0x1) == 0)
7240                                                            {
7241                                                              /* 33222222222211111111110000000000
7242                                                                 10987654321098765432109876543210
7243                                                                 000001x0xx001x01001xxxxxxxxxxxxx
7244                                                                 umaxv.  */
7245                                                              return 1989;
7246                                                            }
7247                                                          else
7248                                                            {
7249                                                              /* 33222222222211111111110000000000
7250                                                                 10987654321098765432109876543210
7251                                                                 000001x0xx011x01001xxxxxxxxxxxxx
7252                                                                 eorv.  */
7253                                                              return 1389;
7254                                                            }
7255                                                        }
7256                                                    }
7257                                                }
7258                                              else
7259                                                {
7260                                                  if (((word >> 16) & 0x1) == 0)
7261                                                    {
7262                                                      if (((word >> 20) & 0x1) == 0)
7263                                                        {
7264                                                          /* 33222222222211111111110000000000
7265                                                             10987654321098765432109876543210
7266                                                             000001x0xx00xx10001xxxxxxxxxxxxx
7267                                                             sminv.  */
7268                                                          return 1843;
7269                                                        }
7270                                                      else
7271                                                        {
7272                                                          /* 33222222222211111111110000000000
7273                                                             10987654321098765432109876543210
7274                                                             000001x0xx01xx10001xxxxxxxxxxxxx
7275                                                             andv.  */
7276                                                          return 1302;
7277                                                        }
7278                                                    }
7279                                                  else
7280                                                    {
7281                                                      /* 33222222222211111111110000000000
7282                                                         10987654321098765432109876543210
7283                                                         000001x0xx0xxx11001xxxxxxxxxxxxx
7284                                                         uminv.  */
7285                                                      return 1992;
7286                                                    }
7287                                                }
7288                                            }
7289                                          else
7290                                            {
7291                                              if (((word >> 23) & 0x1) == 0)
7292                                                {
7293                                                  /* 33222222222211111111110000000000
7294                                                     10987654321098765432109876543210
7295                                                     100001x00x0xxxxx001xxxxxxxxxxxxx
7296                                                     ldff1sb.  */
7297                                                  return 1673;
7298                                                }
7299                                              else
7300                                                {
7301                                                  /* 33222222222211111111110000000000
7302                                                     10987654321098765432109876543210
7303                                                     100001x01x0xxxxx001xxxxxxxxxxxxx
7304                                                     ldff1sh.  */
7305                                                  return 1684;
7306                                                }
7307                                            }
7308                                        }
7309                                      else
7310                                        {
7311                                          if (((word >> 31) & 0x1) == 0)
7312                                            {
7313                                              if (((word >> 12) & 0x1) == 0)
7314                                                {
7315                                                  /* 33222222222211111111110000000000
7316                                                     10987654321098765432109876543210
7317                                                     010001x0xx0xxxxx0010xxxxxxxxxxxx
7318                                                     cmla.  */
7319                                                  return 2074;
7320                                                }
7321                                              else
7322                                                {
7323                                                  /* 33222222222211111111110000000000
7324                                                     10987654321098765432109876543210
7325                                                     010001x0xx0xxxxx0011xxxxxxxxxxxx
7326                                                     sqrdcmlah.  */
7327                                                  return 2206;
7328                                                }
7329                                            }
7330                                          else
7331                                            {
7332                                              if (((word >> 23) & 0x1) == 0)
7333                                                {
7334                                                  /* 33222222222211111111110000000000
7335                                                     10987654321098765432109876543210
7336                                                     110001x00x0xxxxx001xxxxxxxxxxxxx
7337                                                     ldff1sb.  */
7338                                                  return 1680;
7339                                                }
7340                                              else
7341                                                {
7342                                                  /* 33222222222211111111110000000000
7343                                                     10987654321098765432109876543210
7344                                                     110001x01x0xxxxx001xxxxxxxxxxxxx
7345                                                     ldff1sh.  */
7346                                                  return 1690;
7347                                                }
7348                                            }
7349                                        }
7350                                    }
7351                                  else
7352                                    {
7353                                      if (((word >> 30) & 0x1) == 0)
7354                                        {
7355                                          if (((word >> 31) & 0x1) == 0)
7356                                            {
7357                                              if (((word >> 10) & 0x1) == 0)
7358                                                {
7359                                                  if (((word >> 11) & 0x1) == 0)
7360                                                    {
7361                                                      if (((word >> 22) & 0x1) == 0)
7362                                                        {
7363                                                          if (((word >> 23) & 0x1) == 0)
7364                                                            {
7365                                                              /* 33222222222211111111110000000000
7366                                                                 10987654321098765432109876543210
7367                                                                 000001x0001xxxxx001x00xxxxxxxxxx
7368                                                                 and.  */
7369                                                              return 1297;
7370                                                            }
7371                                                          else
7372                                                            {
7373                                                              /* 33222222222211111111110000000000
7374                                                                 10987654321098765432109876543210
7375                                                                 000001x0101xxxxx001x00xxxxxxxxxx
7376                                                                 eor.  */
7377                                                              return 1384;
7378                                                            }
7379                                                        }
7380                                                      else
7381                                                        {
7382                                                          if (((word >> 23) & 0x1) == 0)
7383                                                            {
7384                                                              /* 33222222222211111111110000000000
7385                                                                 10987654321098765432109876543210
7386                                                                 000001x0011xxxxx001x00xxxxxxxxxx
7387                                                                 orr.  */
7388                                                              return 1769;
7389                                                            }
7390                                                          else
7391                                                            {
7392                                                              /* 33222222222211111111110000000000
7393                                                                 10987654321098765432109876543210
7394                                                                 000001x0111xxxxx001x00xxxxxxxxxx
7395                                                                 bic.  */
7396                                                              return 1310;
7397                                                            }
7398                                                        }
7399                                                    }
7400                                                  else
7401                                                    {
7402                                                      if (((word >> 22) & 0x1) == 0)
7403                                                        {
7404                                                          /* 33222222222211111111110000000000
7405                                                             10987654321098765432109876543210
7406                                                             000001x0x01xxxxx001x10xxxxxxxxxx
7407                                                             eor3.  */
7408                                                          return 2077;
7409                                                        }
7410                                                      else
7411                                                        {
7412                                                          /* 33222222222211111111110000000000
7413                                                             10987654321098765432109876543210
7414                                                             000001x0x11xxxxx001x10xxxxxxxxxx
7415                                                             bcax.  */
7416                                                          return 2066;
7417                                                        }
7418                                                    }
7419                                                }
7420                                              else
7421                                                {
7422                                                  if (((word >> 11) & 0x1) == 0)
7423                                                    {
7424                                                      /* 33222222222211111111110000000000
7425                                                         10987654321098765432109876543210
7426                                                         000001x0xx1xxxxx001x01xxxxxxxxxx
7427                                                         xar.  */
7428                                                      return 2339;
7429                                                    }
7430                                                  else
7431                                                    {
7432                                                      if (((word >> 22) & 0x1) == 0)
7433                                                        {
7434                                                          if (((word >> 23) & 0x1) == 0)
7435                                                            {
7436                                                              /* 33222222222211111111110000000000
7437                                                                 10987654321098765432109876543210
7438                                                                 000001x0001xxxxx001x11xxxxxxxxxx
7439                                                                 bsl.  */
7440                                                              return 2067;
7441                                                            }
7442                                                          else
7443                                                            {
7444                                                              /* 33222222222211111111110000000000
7445                                                                 10987654321098765432109876543210
7446                                                                 000001x0101xxxxx001x11xxxxxxxxxx
7447                                                                 bsl2n.  */
7448                                                              return 2069;
7449                                                            }
7450                                                        }
7451                                                      else
7452                                                        {
7453                                                          if (((word >> 23) & 0x1) == 0)
7454                                                            {
7455                                                              /* 33222222222211111111110000000000
7456                                                                 10987654321098765432109876543210
7457                                                                 000001x0011xxxxx001x11xxxxxxxxxx
7458                                                                 bsl1n.  */
7459                                                              return 2068;
7460                                                            }
7461                                                          else
7462                                                            {
7463                                                              /* 33222222222211111111110000000000
7464                                                                 10987654321098765432109876543210
7465                                                                 000001x0111xxxxx001x11xxxxxxxxxx
7466                                                                 nbsl.  */
7467                                                              return 2124;
7468                                                            }
7469                                                        }
7470                                                    }
7471                                                }
7472                                            }
7473                                          else
7474                                            {
7475                                              if (((word >> 23) & 0x1) == 0)
7476                                                {
7477                                                  /* 33222222222211111111110000000000
7478                                                     10987654321098765432109876543210
7479                                                     100001x00x1xxxxx001xxxxxxxxxxxxx
7480                                                     prfh.  */
7481                                                  return 1792;
7482                                                }
7483                                              else
7484                                                {
7485                                                  /* 33222222222211111111110000000000
7486                                                     10987654321098765432109876543210
7487                                                     100001x01x1xxxxx001xxxxxxxxxxxxx
7488                                                     ldff1sh.  */
7489                                                  return 1685;
7490                                                }
7491                                            }
7492                                        }
7493                                      else
7494                                        {
7495                                          if (((word >> 23) & 0x1) == 0)
7496                                            {
7497                                              /* 33222222222211111111110000000000
7498                                                 10987654321098765432109876543210
7499                                                 x10001x00x1xxxxx001xxxxxxxxxxxxx
7500                                                 prfh.  */
7501                                              return 1794;
7502                                            }
7503                                          else
7504                                            {
7505                                              if (((word >> 31) & 0x1) == 0)
7506                                                {
7507                                                  if (((word >> 10) & 0x1) == 0)
7508                                                    {
7509                                                      if (((word >> 12) & 0x1) == 0)
7510                                                        {
7511                                                          if (((word >> 22) & 0x1) == 0)
7512                                                            {
7513                                                              /* 33222222222211111111110000000000
7514                                                                 10987654321098765432109876543210
7515                                                                 010001x0101xxxxx0010x0xxxxxxxxxx
7516                                                                 sqdmlalb.  */
7517                                                              return 2179;
7518                                                            }
7519                                                          else
7520                                                            {
7521                                                              /* 33222222222211111111110000000000
7522                                                                 10987654321098765432109876543210
7523                                                                 010001x0111xxxxx0010x0xxxxxxxxxx
7524                                                                 sqdmlalb.  */
7525                                                              return 2180;
7526                                                            }
7527                                                        }
7528                                                      else
7529                                                        {
7530                                                          if (((word >> 22) & 0x1) == 0)
7531                                                            {
7532                                                              /* 33222222222211111111110000000000
7533                                                                 10987654321098765432109876543210
7534                                                                 010001x0101xxxxx0011x0xxxxxxxxxx
7535                                                                 sqdmlslb.  */
7536                                                              return 2186;
7537                                                            }
7538                                                          else
7539                                                            {
7540                                                              /* 33222222222211111111110000000000
7541                                                                 10987654321098765432109876543210
7542                                                                 010001x0111xxxxx0011x0xxxxxxxxxx
7543                                                                 sqdmlslb.  */
7544                                                              return 2187;
7545                                                            }
7546                                                        }
7547                                                    }
7548                                                  else
7549                                                    {
7550                                                      if (((word >> 12) & 0x1) == 0)
7551                                                        {
7552                                                          if (((word >> 22) & 0x1) == 0)
7553                                                            {
7554                                                              /* 33222222222211111111110000000000
7555                                                                 10987654321098765432109876543210
7556                                                                 010001x0101xxxxx0010x1xxxxxxxxxx
7557                                                                 sqdmlalt.  */
7558                                                              return 2183;
7559                                                            }
7560                                                          else
7561                                                            {
7562                                                              /* 33222222222211111111110000000000
7563                                                                 10987654321098765432109876543210
7564                                                                 010001x0111xxxxx0010x1xxxxxxxxxx
7565                                                                 sqdmlalt.  */
7566                                                              return 2184;
7567                                                            }
7568                                                        }
7569                                                      else
7570                                                        {
7571                                                          if (((word >> 22) & 0x1) == 0)
7572                                                            {
7573                                                              /* 33222222222211111111110000000000
7574                                                                 10987654321098765432109876543210
7575                                                                 010001x0101xxxxx0011x1xxxxxxxxxx
7576                                                                 sqdmlslt.  */
7577                                                              return 2190;
7578                                                            }
7579                                                          else
7580                                                            {
7581                                                              /* 33222222222211111111110000000000
7582                                                                 10987654321098765432109876543210
7583                                                                 010001x0111xxxxx0011x1xxxxxxxxxx
7584                                                                 sqdmlslt.  */
7585                                                              return 2191;
7586                                                            }
7587                                                        }
7588                                                    }
7589                                                }
7590                                              else
7591                                                {
7592                                                  /* 33222222222211111111110000000000
7593                                                     10987654321098765432109876543210
7594                                                     110001x01x1xxxxx001xxxxxxxxxxxxx
7595                                                     ldff1sh.  */
7596                                                  return 1691;
7597                                                }
7598                                            }
7599                                        }
7600                                    }
7601                                }
7602                              else
7603                                {
7604                                  if (((word >> 30) & 0x1) == 0)
7605                                    {
7606                                      if (((word >> 31) & 0x1) == 0)
7607                                        {
7608                                          if (((word >> 21) & 0x1) == 0)
7609                                            {
7610                                              if (((word >> 16) & 0x1) == 0)
7611                                                {
7612                                                  if (((word >> 17) & 0x1) == 0)
7613                                                    {
7614                                                      if (((word >> 18) & 0x1) == 0)
7615                                                        {
7616                                                          if (((word >> 19) & 0x1) == 0)
7617                                                            {
7618                                                              /* 33222222222211111111110000000000
7619                                                                 10987654321098765432109876543210
7620                                                                 000001x0xx0x0000101xxxxxxxxxxxxx
7621                                                                 sxtb.  */
7622                                                              return 1965;
7623                                                            }
7624                                                          else
7625                                                            {
7626                                                              /* 33222222222211111111110000000000
7627                                                                 10987654321098765432109876543210
7628                                                                 000001x0xx0x1000101xxxxxxxxxxxxx
7629                                                                 cls.  */
7630                                                              return 1330;
7631                                                            }
7632                                                        }
7633                                                      else
7634                                                        {
7635                                                          if (((word >> 19) & 0x1) == 0)
7636                                                            {
7637                                                              /* 33222222222211111111110000000000
7638                                                                 10987654321098765432109876543210
7639                                                                 000001x0xx0x0100101xxxxxxxxxxxxx
7640                                                                 sxtw.  */
7641                                                              return 1967;
7642                                                            }
7643                                                          else
7644                                                            {
7645                                                              /* 33222222222211111111110000000000
7646                                                                 10987654321098765432109876543210
7647                                                                 000001x0xx0x1100101xxxxxxxxxxxxx
7648                                                                 fabs.  */
7649                                                              return 1392;
7650                                                            }
7651                                                        }
7652                                                    }
7653                                                  else
7654                                                    {
7655                                                      if (((word >> 18) & 0x1) == 0)
7656                                                        {
7657                                                          if (((word >> 19) & 0x1) == 0)
7658                                                            {
7659                                                              /* 33222222222211111111110000000000
7660                                                                 10987654321098765432109876543210
7661                                                                 000001x0xx0x0010101xxxxxxxxxxxxx
7662                                                                 sxth.  */
7663                                                              return 1966;
7664                                                            }
7665                                                          else
7666                                                            {
7667                                                              /* 33222222222211111111110000000000
7668                                                                 10987654321098765432109876543210
7669                                                                 000001x0xx0x1010101xxxxxxxxxxxxx
7670                                                                 cnt.  */
7671                                                              return 1359;
7672                                                            }
7673                                                        }
7674                                                      else
7675                                                        {
7676                                                          if (((word >> 19) & 0x1) == 0)
7677                                                            {
7678                                                              /* 33222222222211111111110000000000
7679                                                                 10987654321098765432109876543210
7680                                                                 000001x0xx0x0110101xxxxxxxxxxxxx
7681                                                                 abs.  */
7682                                                              return 1288;
7683                                                            }
7684                                                          else
7685                                                            {
7686                                                              /* 33222222222211111111110000000000
7687                                                                 10987654321098765432109876543210
7688                                                                 000001x0xx0x1110101xxxxxxxxxxxxx
7689                                                                 not.  */
7690                                                              return 1766;
7691                                                            }
7692                                                        }
7693                                                    }
7694                                                }
7695                                              else
7696                                                {
7697                                                  if (((word >> 17) & 0x1) == 0)
7698                                                    {
7699                                                      if (((word >> 18) & 0x1) == 0)
7700                                                        {
7701                                                          if (((word >> 19) & 0x1) == 0)
7702                                                            {
7703                                                              /* 33222222222211111111110000000000
7704                                                                 10987654321098765432109876543210
7705                                                                 000001x0xx0x0001101xxxxxxxxxxxxx
7706                                                                 uxtb.  */
7707                                                              return 2028;
7708                                                            }
7709                                                          else
7710                                                            {
7711                                                              /* 33222222222211111111110000000000
7712                                                                 10987654321098765432109876543210
7713                                                                 000001x0xx0x1001101xxxxxxxxxxxxx
7714                                                                 clz.  */
7715                                                              return 1331;
7716                                                            }
7717                                                        }
7718                                                      else
7719                                                        {
7720                                                          if (((word >> 19) & 0x1) == 0)
7721                                                            {
7722                                                              /* 33222222222211111111110000000000
7723                                                                 10987654321098765432109876543210
7724                                                                 000001x0xx0x0101101xxxxxxxxxxxxx
7725                                                                 uxtw.  */
7726                                                              return 2030;
7727                                                            }
7728                                                          else
7729                                                            {
7730                                                              /* 33222222222211111111110000000000
7731                                                                 10987654321098765432109876543210
7732                                                                 000001x0xx0x1101101xxxxxxxxxxxxx
7733                                                                 fneg.  */
7734                                                              return 1469;
7735                                                            }
7736                                                        }
7737                                                    }
7738                                                  else
7739                                                    {
7740                                                      if (((word >> 18) & 0x1) == 0)
7741                                                        {
7742                                                          if (((word >> 19) & 0x1) == 0)
7743                                                            {
7744                                                              /* 33222222222211111111110000000000
7745                                                                 10987654321098765432109876543210
7746                                                                 000001x0xx0x0011101xxxxxxxxxxxxx
7747                                                                 uxth.  */
7748                                                              return 2029;
7749                                                            }
7750                                                          else
7751                                                            {
7752                                                              /* 33222222222211111111110000000000
7753                                                                 10987654321098765432109876543210
7754                                                                 000001x0xx0x1011101xxxxxxxxxxxxx
7755                                                                 cnot.  */
7756                                                              return 1358;
7757                                                            }
7758                                                        }
7759                                                      else
7760                                                        {
7761                                                          /* 33222222222211111111110000000000
7762                                                             10987654321098765432109876543210
7763                                                             000001x0xx0xx111101xxxxxxxxxxxxx
7764                                                             neg.  */
7765                                                          return 1763;
7766                                                        }
7767                                                    }
7768                                                }
7769                                            }
7770                                          else
7771                                            {
7772                                              if (((word >> 12) & 0x1) == 0)
7773                                                {
7774                                                  if (((word >> 23) & 0x1) == 0)
7775                                                    {
7776                                                      if (((word >> 22) & 0x1) == 0)
7777                                                        {
7778                                                          /* 33222222222211111111110000000000
7779                                                             10987654321098765432109876543210
7780                                                             000001x0001xxxxx1010xxxxxxxxxxxx
7781                                                             adr.  */
7782                                                          return 1294;
7783                                                        }
7784                                                      else
7785                                                        {
7786                                                          /* 33222222222211111111110000000000
7787                                                             10987654321098765432109876543210
7788                                                             000001x0011xxxxx1010xxxxxxxxxxxx
7789                                                             adr.  */
7790                                                          return 1295;
7791                                                        }
7792                                                    }
7793                                                  else
7794                                                    {
7795                                                      /* 33222222222211111111110000000000
7796                                                         10987654321098765432109876543210
7797                                                         000001x01x1xxxxx1010xxxxxxxxxxxx
7798                                                         adr.  */
7799                                                      return 1296;
7800                                                    }
7801                                                }
7802                                              else
7803                                                {
7804                                                  if (((word >> 10) & 0x1) == 0)
7805                                                    {
7806                                                      if (((word >> 11) & 0x1) == 0)
7807                                                        {
7808                                                          /* 33222222222211111111110000000000
7809                                                             10987654321098765432109876543210
7810                                                             000001x0xx1xxxxx101100xxxxxxxxxx
7811                                                             ftssel.  */
7812                                                          return 1495;
7813                                                        }
7814                                                      else
7815                                                        {
7816                                                          /* 33222222222211111111110000000000
7817                                                             10987654321098765432109876543210
7818                                                             000001x0xx1xxxxx101110xxxxxxxxxx
7819                                                             fexpa.  */
7820                                                          return 1439;
7821                                                        }
7822                                                    }
7823                                                  else
7824                                                    {
7825                                                      /* 33222222222211111111110000000000
7826                                                         10987654321098765432109876543210
7827                                                         000001x0xx1xxxxx1011x1xxxxxxxxxx
7828                                                         movprfx.  */
7829                                                      return 1756;
7830                                                    }
7831                                                }
7832                                            }
7833                                        }
7834                                      else
7835                                        {
7836                                          if (((word >> 22) & 0x1) == 0)
7837                                            {
7838                                              if (((word >> 21) & 0x1) == 0)
7839                                                {
7840                                                  if (((word >> 23) & 0x1) == 0)
7841                                                    {
7842                                                      /* 33222222222211111111110000000000
7843                                                         10987654321098765432109876543210
7844                                                         100001x0000xxxxx101xxxxxxxxxxxxx
7845                                                         ldnt1b.  */
7846                                                      return 2103;
7847                                                    }
7848                                                  else
7849                                                    {
7850                                                      /* 33222222222211111111110000000000
7851                                                         10987654321098765432109876543210
7852                                                         100001x0100xxxxx101xxxxxxxxxxxxx
7853                                                         ldnt1h.  */
7854                                                      return 2106;
7855                                                    }
7856                                                }
7857                                              else
7858                                                {
7859                                                  if (((word >> 23) & 0x1) == 0)
7860                                                    {
7861                                                      /* 33222222222211111111110000000000
7862                                                         10987654321098765432109876543210
7863                                                         100001x0001xxxxx101xxxxxxxxxxxxx
7864                                                         ldff1sb.  */
7865                                                      return 1682;
7866                                                    }
7867                                                  else
7868                                                    {
7869                                                      /* 33222222222211111111110000000000
7870                                                         10987654321098765432109876543210
7871                                                         100001x0101xxxxx101xxxxxxxxxxxxx
7872                                                         ldff1sh.  */
7873                                                      return 1694;
7874                                                    }
7875                                                }
7876                                            }
7877                                          else
7878                                            {
7879                                              if (((word >> 23) & 0x1) == 0)
7880                                                {
7881                                                  /* 33222222222211111111110000000000
7882                                                     10987654321098765432109876543210
7883                                                     100001x001xxxxxx101xxxxxxxxxxxxx
7884                                                     ld1rb.  */
7885                                                  return 1550;
7886                                                }
7887                                              else
7888                                                {
7889                                                  /* 33222222222211111111110000000000
7890                                                     10987654321098765432109876543210
7891                                                     100001x011xxxxxx101xxxxxxxxxxxxx
7892                                                     ld1rh.  */
7893                                                  return 1554;
7894                                                }
7895                                            }
7896                                        }
7897                                    }
7898                                  else
7899                                    {
7900                                      if (((word >> 21) & 0x1) == 0)
7901                                        {
7902                                          if (((word >> 31) & 0x1) == 0)
7903                                            {
7904                                              if (((word >> 16) & 0x1) == 0)
7905                                                {
7906                                                  if (((word >> 17) & 0x1) == 0)
7907                                                    {
7908                                                      if (((word >> 18) & 0x1) == 0)
7909                                                        {
7910                                                          if (((word >> 19) & 0x1) == 0)
7911                                                            {
7912                                                              /* 33222222222211111111110000000000
7913                                                                 10987654321098765432109876543210
7914                                                                 010001x0xx0x0000101xxxxxxxxxxxxx
7915                                                                 urecpe.  */
7916                                                              return 2314;
7917                                                            }
7918                                                          else
7919                                                            {
7920                                                              /* 33222222222211111111110000000000
7921                                                                 10987654321098765432109876543210
7922                                                                 010001x0xx0x1000101xxxxxxxxxxxxx
7923                                                                 sqabs.  */
7924                                                              return 2176;
7925                                                            }
7926                                                        }
7927                                                      else
7928                                                        {
7929                                                          if (((word >> 20) & 0x1) == 0)
7930                                                            {
7931                                                              /* 33222222222211111111110000000000
7932                                                                 10987654321098765432109876543210
7933                                                                 010001x0xx00x100101xxxxxxxxxxxxx
7934                                                                 sadalp.  */
7935                                                              return 2140;
7936                                                            }
7937                                                          else
7938                                                            {
7939                                                              /* 33222222222211111111110000000000
7940                                                                 10987654321098765432109876543210
7941                                                                 010001x0xx01x100101xxxxxxxxxxxxx
7942                                                                 smaxp.  */
7943                                                              return 2154;
7944                                                            }
7945                                                        }
7946                                                    }
7947                                                  else
7948                                                    {
7949                                                      /* 33222222222211111111110000000000
7950                                                         10987654321098765432109876543210
7951                                                         010001x0xx0xxx10101xxxxxxxxxxxxx
7952                                                         sminp.  */
7953                                                      return 2155;
7954                                                    }
7955                                                }
7956                                              else
7957                                                {
7958                                                  if (((word >> 17) & 0x1) == 0)
7959                                                    {
7960                                                      if (((word >> 18) & 0x1) == 0)
7961                                                        {
7962                                                          if (((word >> 19) & 0x1) == 0)
7963                                                            {
7964                                                              if (((word >> 20) & 0x1) == 0)
7965                                                                {
7966                                                                  /* 33222222222211111111110000000000
7967                                                                     10987654321098765432109876543210
7968                                                                     010001x0xx000001101xxxxxxxxxxxxx
7969                                                                     ursqrte.  */
7970                                                                  return 2319;
7971                                                                }
7972                                                              else
7973                                                                {
7974                                                                  /* 33222222222211111111110000000000
7975                                                                     10987654321098765432109876543210
7976                                                                     010001x0xx010001101xxxxxxxxxxxxx
7977                                                                     addp.  */
7978                                                                  return 2065;
7979                                                                }
7980                                                            }
7981                                                          else
7982                                                            {
7983                                                              /* 33222222222211111111110000000000
7984                                                                 10987654321098765432109876543210
7985                                                                 010001x0xx0x1001101xxxxxxxxxxxxx
7986                                                                 sqneg.  */
7987                                                              return 2203;
7988                                                            }
7989                                                        }
7990                                                      else
7991                                                        {
7992                                                          if (((word >> 20) & 0x1) == 0)
7993                                                            {
7994                                                              /* 33222222222211111111110000000000
7995                                                                 10987654321098765432109876543210
7996                                                                 010001x0xx00x101101xxxxxxxxxxxxx
7997                                                                 uadalp.  */
7998                                                              return 2271;
7999                                                            }
8000                                                          else
8001                                                            {
8002                                                              /* 33222222222211111111110000000000
8003                                                                 10987654321098765432109876543210
8004                                                                 010001x0xx01x101101xxxxxxxxxxxxx
8005                                                                 umaxp.  */
8006                                                              return 2279;
8007                                                            }
8008                                                        }
8009                                                    }
8010                                                  else
8011                                                    {
8012                                                      /* 33222222222211111111110000000000
8013                                                         10987654321098765432109876543210
8014                                                         010001x0xx0xxx11101xxxxxxxxxxxxx
8015                                                         uminp.  */
8016                                                      return 2280;
8017                                                    }
8018                                                }
8019                                            }
8020                                          else
8021                                            {
8022                                              if (((word >> 23) & 0x1) == 0)
8023                                                {
8024                                                  /* 33222222222211111111110000000000
8025                                                     10987654321098765432109876543210
8026                                                     110001x00x0xxxxx101xxxxxxxxxxxxx
8027                                                     ldff1sb.  */
8028                                                  return 1681;
8029                                                }
8030                                              else
8031                                                {
8032                                                  /* 33222222222211111111110000000000
8033                                                     10987654321098765432109876543210
8034                                                     110001x01x0xxxxx101xxxxxxxxxxxxx
8035                                                     ldff1sh.  */
8036                                                  return 1692;
8037                                                }
8038                                            }
8039                                        }
8040                                      else
8041                                        {
8042                                          if (((word >> 22) & 0x1) == 0)
8043                                            {
8044                                              if (((word >> 23) & 0x1) == 0)
8045                                                {
8046                                                  /* 33222222222211111111110000000000
8047                                                     10987654321098765432109876543210
8048                                                     x10001x0001xxxxx101xxxxxxxxxxxxx
8049                                                     ldff1sb.  */
8050                                                  return 1683;
8051                                                }
8052                                              else
8053                                                {
8054                                                  if (((word >> 31) & 0x1) == 0)
8055                                                    {
8056                                                      if (((word >> 10) & 0x1) == 0)
8057                                                        {
8058                                                          if (((word >> 12) & 0x1) == 0)
8059                                                            {
8060                                                              /* 33222222222211111111110000000000
8061                                                                 10987654321098765432109876543210
8062                                                                 010001x0101xxxxx1010x0xxxxxxxxxx
8063                                                                 smlslb.  */
8064                                                              return 2162;
8065                                                            }
8066                                                          else
8067                                                            {
8068                                                              /* 33222222222211111111110000000000
8069                                                                 10987654321098765432109876543210
8070                                                                 010001x0101xxxxx1011x0xxxxxxxxxx
8071                                                                 umlslb.  */
8072                                                              return 2287;
8073                                                            }
8074                                                        }
8075                                                      else
8076                                                        {
8077                                                          if (((word >> 12) & 0x1) == 0)
8078                                                            {
8079                                                              /* 33222222222211111111110000000000
8080                                                                 10987654321098765432109876543210
8081                                                                 010001x0101xxxxx1010x1xxxxxxxxxx
8082                                                                 smlslt.  */
8083                                                              return 2165;
8084                                                            }
8085                                                          else
8086                                                            {
8087                                                              /* 33222222222211111111110000000000
8088                                                                 10987654321098765432109876543210
8089                                                                 010001x0101xxxxx1011x1xxxxxxxxxx
8090                                                                 umlslt.  */
8091                                                              return 2290;
8092                                                            }
8093                                                        }
8094                                                    }
8095                                                  else
8096                                                    {
8097                                                      /* 33222222222211111111110000000000
8098                                                         10987654321098765432109876543210
8099                                                         110001x0101xxxxx101xxxxxxxxxxxxx
8100                                                         ldff1sh.  */
8101                                                      return 1695;
8102                                                    }
8103                                                }
8104                                            }
8105                                          else
8106                                            {
8107                                              if (((word >> 23) & 0x1) == 0)
8108                                                {
8109                                                  /* 33222222222211111111110000000000
8110                                                     10987654321098765432109876543210
8111                                                     x10001x0011xxxxx101xxxxxxxxxxxxx
8112                                                     prfh.  */
8113                                                  return 1795;
8114                                                }
8115                                              else
8116                                                {
8117                                                  if (((word >> 31) & 0x1) == 0)
8118                                                    {
8119                                                      if (((word >> 10) & 0x1) == 0)
8120                                                        {
8121                                                          if (((word >> 12) & 0x1) == 0)
8122                                                            {
8123                                                              /* 33222222222211111111110000000000
8124                                                                 10987654321098765432109876543210
8125                                                                 010001x0111xxxxx1010x0xxxxxxxxxx
8126                                                                 smlslb.  */
8127                                                              return 2163;
8128                                                            }
8129                                                          else
8130                                                            {
8131                                                              /* 33222222222211111111110000000000
8132                                                                 10987654321098765432109876543210
8133                                                                 010001x0111xxxxx1011x0xxxxxxxxxx
8134                                                                 umlslb.  */
8135                                                              return 2288;
8136                                                            }
8137                                                        }
8138                                                      else
8139                                                        {
8140                                                          if (((word >> 12) & 0x1) == 0)
8141                                                            {
8142                                                              /* 33222222222211111111110000000000
8143                                                                 10987654321098765432109876543210
8144                                                                 010001x0111xxxxx1010x1xxxxxxxxxx
8145                                                                 smlslt.  */
8146                                                              return 2166;
8147                                                            }
8148                                                          else
8149                                                            {
8150                                                              /* 33222222222211111111110000000000
8151                                                                 10987654321098765432109876543210
8152                                                                 010001x0111xxxxx1011x1xxxxxxxxxx
8153                                                                 umlslt.  */
8154                                                              return 2291;
8155                                                            }
8156                                                        }
8157                                                    }
8158                                                  else
8159                                                    {
8160                                                      /* 33222222222211111111110000000000
8161                                                         10987654321098765432109876543210
8162                                                         110001x0111xxxxx101xxxxxxxxxxxxx
8163                                                         ldff1sh.  */
8164                                                      return 1693;
8165                                                    }
8166                                                }
8167                                            }
8168                                        }
8169                                    }
8170                                }
8171                            }
8172                          else
8173                            {
8174                              if (((word >> 15) & 0x1) == 0)
8175                                {
8176                                  if (((word >> 21) & 0x1) == 0)
8177                                    {
8178                                      if (((word >> 30) & 0x1) == 0)
8179                                        {
8180                                          if (((word >> 31) & 0x1) == 0)
8181                                            {
8182                                              /* 33222222222211111111110000000000
8183                                                 10987654321098765432109876543210
8184                                                 000001x0xx0xxxxx011xxxxxxxxxxxxx
8185                                                 mls.  */
8186                                              return 1755;
8187                                            }
8188                                          else
8189                                            {
8190                                              if (((word >> 23) & 0x1) == 0)
8191                                                {
8192                                                  /* 33222222222211111111110000000000
8193                                                     10987654321098765432109876543210
8194                                                     100001x00x0xxxxx011xxxxxxxxxxxxx
8195                                                     ldff1b.  */
8196                                                  return 1639;
8197                                                }
8198                                              else
8199                                                {
8200                                                  /* 33222222222211111111110000000000
8201                                                     10987654321098765432109876543210
8202                                                     100001x01x0xxxxx011xxxxxxxxxxxxx
8203                                                     ldff1h.  */
8204                                                  return 1659;
8205                                                }
8206                                            }
8207                                        }
8208                                      else
8209                                        {
8210                                          if (((word >> 31) & 0x1) == 0)
8211                                            {
8212                                              if (((word >> 10) & 0x1) == 0)
8213                                                {
8214                                                  if (((word >> 11) & 0x1) == 0)
8215                                                    {
8216                                                      if (((word >> 12) & 0x1) == 0)
8217                                                        {
8218                                                          /* 33222222222211111111110000000000
8219                                                             10987654321098765432109876543210
8220                                                             010001x0xx0xxxxx011000xxxxxxxxxx
8221                                                             sqdmlalb.  */
8222                                                          return 2181;
8223                                                        }
8224                                                      else
8225                                                        {
8226                                                          /* 33222222222211111111110000000000
8227                                                             10987654321098765432109876543210
8228                                                             010001x0xx0xxxxx011100xxxxxxxxxx
8229                                                             sqrdmlah.  */
8230                                                          return 2210;
8231                                                        }
8232                                                    }
8233                                                  else
8234                                                    {
8235                                                      if (((word >> 12) & 0x1) == 0)
8236                                                        {
8237                                                          /* 33222222222211111111110000000000
8238                                                             10987654321098765432109876543210
8239                                                             010001x0xx0xxxxx011010xxxxxxxxxx
8240                                                             sqdmlslb.  */
8241                                                          return 2188;
8242                                                        }
8243                                                      else
8244                                                        {
8245                                                          /* 33222222222211111111110000000000
8246                                                             10987654321098765432109876543210
8247                                                             010001x0xx0xxxxx011110xxxxxxxxxx
8248                                                             usdot.  */
8249                                                          return 2470;
8250                                                        }
8251                                                    }
8252                                                }
8253                                              else
8254                                                {
8255                                                  if (((word >> 11) & 0x1) == 0)
8256                                                    {
8257                                                      if (((word >> 12) & 0x1) == 0)
8258                                                        {
8259                                                          /* 33222222222211111111110000000000
8260                                                             10987654321098765432109876543210
8261                                                             010001x0xx0xxxxx011001xxxxxxxxxx
8262                                                             sqdmlalt.  */
8263                                                          return 2185;
8264                                                        }
8265                                                      else
8266                                                        {
8267                                                          /* 33222222222211111111110000000000
8268                                                             10987654321098765432109876543210
8269                                                             010001x0xx0xxxxx011101xxxxxxxxxx
8270                                                             sqrdmlsh.  */
8271                                                          return 2214;
8272                                                        }
8273                                                    }
8274                                                  else
8275                                                    {
8276                                                      /* 33222222222211111111110000000000
8277                                                         10987654321098765432109876543210
8278                                                         010001x0xx0xxxxx011x11xxxxxxxxxx
8279                                                         sqdmlslt.  */
8280                                                      return 2192;
8281                                                    }
8282                                                }
8283                                            }
8284                                          else
8285                                            {
8286                                              if (((word >> 23) & 0x1) == 0)
8287                                                {
8288                                                  /* 33222222222211111111110000000000
8289                                                     10987654321098765432109876543210
8290                                                     110001x00x0xxxxx011xxxxxxxxxxxxx
8291                                                     ldff1b.  */
8292                                                  return 1648;
8293                                                }
8294                                              else
8295                                                {
8296                                                  /* 33222222222211111111110000000000
8297                                                     10987654321098765432109876543210
8298                                                     110001x01x0xxxxx011xxxxxxxxxxxxx
8299                                                     ldff1h.  */
8300                                                  return 1667;
8301                                                }
8302                                            }
8303                                        }
8304                                    }
8305                                  else
8306                                    {
8307                                      if (((word >> 30) & 0x1) == 0)
8308                                        {
8309                                          if (((word >> 31) & 0x1) == 0)
8310                                            {
8311                                              if (((word >> 10) & 0x1) == 0)
8312                                                {
8313                                                  if (((word >> 11) & 0x1) == 0)
8314                                                    {
8315                                                      if (((word >> 12) & 0x1) == 0)
8316                                                        {
8317                                                          /* 33222222222211111111110000000000
8318                                                             10987654321098765432109876543210
8319                                                             000001x0xx1xxxxx011000xxxxxxxxxx
8320                                                             mul.  */
8321                                                          return 2123;
8322                                                        }
8323                                                      else
8324                                                        {
8325                                                          /* 33222222222211111111110000000000
8326                                                             10987654321098765432109876543210
8327                                                             000001x0xx1xxxxx011100xxxxxxxxxx
8328                                                             sqdmulh.  */
8329                                                          return 2196;
8330                                                        }
8331                                                    }
8332                                                  else
8333                                                    {
8334                                                      /* 33222222222211111111110000000000
8335                                                         10987654321098765432109876543210
8336                                                         000001x0xx1xxxxx011x10xxxxxxxxxx
8337                                                         smulh.  */
8338                                                      return 2168;
8339                                                    }
8340                                                }
8341                                              else
8342                                                {
8343                                                  if (((word >> 11) & 0x1) == 0)
8344                                                    {
8345                                                      if (((word >> 12) & 0x1) == 0)
8346                                                        {
8347                                                          /* 33222222222211111111110000000000
8348                                                             10987654321098765432109876543210
8349                                                             000001x0xx1xxxxx011001xxxxxxxxxx
8350                                                             pmul.  */
8351                                                          return 2126;
8352                                                        }
8353                                                      else
8354                                                        {
8355                                                          /* 33222222222211111111110000000000
8356                                                             10987654321098765432109876543210
8357                                                             000001x0xx1xxxxx011101xxxxxxxxxx
8358                                                             sqrdmulh.  */
8359                                                          return 2218;
8360                                                        }
8361                                                    }
8362                                                  else
8363                                                    {
8364                                                      /* 33222222222211111111110000000000
8365                                                         10987654321098765432109876543210
8366                                                         000001x0xx1xxxxx011x11xxxxxxxxxx
8367                                                         umulh.  */
8368                                                      return 2293;
8369                                                    }
8370                                                }
8371                                            }
8372                                          else
8373                                            {
8374                                              if (((word >> 23) & 0x1) == 0)
8375                                                {
8376                                                  /* 33222222222211111111110000000000
8377                                                     10987654321098765432109876543210
8378                                                     100001x00x1xxxxx011xxxxxxxxxxxxx
8379                                                     prfd.  */
8380                                                  return 1785;
8381                                                }
8382                                              else
8383                                                {
8384                                                  /* 33222222222211111111110000000000
8385                                                     10987654321098765432109876543210
8386                                                     100001x01x1xxxxx011xxxxxxxxxxxxx
8387                                                     ldff1h.  */
8388                                                  return 1660;
8389                                                }
8390                                            }
8391                                        }
8392                                      else
8393                                        {
8394                                          if (((word >> 23) & 0x1) == 0)
8395                                            {
8396                                              /* 33222222222211111111110000000000
8397                                                 10987654321098765432109876543210
8398                                                 x10001x00x1xxxxx011xxxxxxxxxxxxx
8399                                                 prfd.  */
8400                                              return 1787;
8401                                            }
8402                                          else
8403                                            {
8404                                              if (((word >> 31) & 0x1) == 0)
8405                                                {
8406                                                  if (((word >> 12) & 0x1) == 0)
8407                                                    {
8408                                                      if (((word >> 22) & 0x1) == 0)
8409                                                        {
8410                                                          /* 33222222222211111111110000000000
8411                                                             10987654321098765432109876543210
8412                                                             010001x0101xxxxx0110xxxxxxxxxxxx
8413                                                             cmla.  */
8414                                                          return 2075;
8415                                                        }
8416                                                      else
8417                                                        {
8418                                                          /* 33222222222211111111110000000000
8419                                                             10987654321098765432109876543210
8420                                                             010001x0111xxxxx0110xxxxxxxxxxxx
8421                                                             cmla.  */
8422                                                          return 2076;
8423                                                        }
8424                                                    }
8425                                                  else
8426                                                    {
8427                                                      if (((word >> 22) & 0x1) == 0)
8428                                                        {
8429                                                          /* 33222222222211111111110000000000
8430                                                             10987654321098765432109876543210
8431                                                             010001x0101xxxxx0111xxxxxxxxxxxx
8432                                                             sqrdcmlah.  */
8433                                                          return 2204;
8434                                                        }
8435                                                      else
8436                                                        {
8437                                                          /* 33222222222211111111110000000000
8438                                                             10987654321098765432109876543210
8439                                                             010001x0111xxxxx0111xxxxxxxxxxxx
8440                                                             sqrdcmlah.  */
8441                                                          return 2205;
8442                                                        }
8443                                                    }
8444                                                }
8445                                              else
8446                                                {
8447                                                  /* 33222222222211111111110000000000
8448                                                     10987654321098765432109876543210
8449                                                     110001x01x1xxxxx011xxxxxxxxxxxxx
8450                                                     ldff1h.  */
8451                                                  return 1668;
8452                                                }
8453                                            }
8454                                        }
8455                                    }
8456                                }
8457                              else
8458                                {
8459                                  if (((word >> 30) & 0x1) == 0)
8460                                    {
8461                                      if (((word >> 31) & 0x1) == 0)
8462                                        {
8463                                          if (((word >> 21) & 0x1) == 0)
8464                                            {
8465                                              /* 33222222222211111111110000000000
8466                                                 10987654321098765432109876543210
8467                                                 000001x0xx0xxxxx111xxxxxxxxxxxxx
8468                                                 msb.  */
8469                                              return 1758;
8470                                            }
8471                                          else
8472                                            {
8473                                              if (((word >> 10) & 0x1) == 0)
8474                                                {
8475                                                  if (((word >> 11) & 0x1) == 0)
8476                                                    {
8477                                                      if (((word >> 12) & 0x1) == 0)
8478                                                        {
8479                                                          if (((word >> 20) & 0x1) == 0)
8480                                                            {
8481                                                              if (((word >> 22) & 0x1) == 0)
8482                                                                {
8483                                                                  if (((word >> 23) & 0x1) == 0)
8484                                                                    {
8485                                                                      /* 33222222222211111111110000000000
8486                                                                         10987654321098765432109876543210
8487                                                                         000001x00010xxxx111000xxxxxxxxxx
8488                                                                         cntb.  */
8489                                                                      return 1360;
8490                                                                    }
8491                                                                  else
8492                                                                    {
8493                                                                      /* 33222222222211111111110000000000
8494                                                                         10987654321098765432109876543210
8495                                                                         000001x01010xxxx111000xxxxxxxxxx
8496                                                                         cntw.  */
8497                                                                      return 1364;
8498                                                                    }
8499                                                                }
8500                                                              else
8501                                                                {
8502                                                                  if (((word >> 23) & 0x1) == 0)
8503                                                                    {
8504                                                                      /* 33222222222211111111110000000000
8505                                                                         10987654321098765432109876543210
8506                                                                         000001x00110xxxx111000xxxxxxxxxx
8507                                                                         cnth.  */
8508                                                                      return 1362;
8509                                                                    }
8510                                                                  else
8511                                                                    {
8512                                                                      /* 33222222222211111111110000000000
8513                                                                         10987654321098765432109876543210
8514                                                                         000001x01110xxxx111000xxxxxxxxxx
8515                                                                         cntd.  */
8516                                                                      return 1361;
8517                                                                    }
8518                                                                }
8519                                                            }
8520                                                          else
8521                                                            {
8522                                                              if (((word >> 22) & 0x1) == 0)
8523                                                                {
8524                                                                  if (((word >> 23) & 0x1) == 0)
8525                                                                    {
8526                                                                      /* 33222222222211111111110000000000
8527                                                                         10987654321098765432109876543210
8528                                                                         000001x00011xxxx111000xxxxxxxxxx
8529                                                                         incb.  */
8530                                                                      return 1496;
8531                                                                    }
8532                                                                  else
8533                                                                    {
8534                                                                      /* 33222222222211111111110000000000
8535                                                                         10987654321098765432109876543210
8536                                                                         000001x01011xxxx111000xxxxxxxxxx
8537                                                                         incw.  */
8538                                                                      return 1504;
8539                                                                    }
8540                                                                }
8541                                                              else
8542                                                                {
8543                                                                  if (((word >> 23) & 0x1) == 0)
8544                                                                    {
8545                                                                      /* 33222222222211111111110000000000
8546                                                                         10987654321098765432109876543210
8547                                                                         000001x00111xxxx111000xxxxxxxxxx
8548                                                                         inch.  */
8549                                                                      return 1500;
8550                                                                    }
8551                                                                  else
8552                                                                    {
8553                                                                      /* 33222222222211111111110000000000
8554                                                                         10987654321098765432109876543210
8555                                                                         000001x01111xxxx111000xxxxxxxxxx
8556                                                                         incd.  */
8557                                                                      return 1498;
8558                                                                    }
8559                                                                }
8560                                                            }
8561                                                        }
8562                                                      else
8563                                                        {
8564                                                          if (((word >> 20) & 0x1) == 0)
8565                                                            {
8566                                                              if (((word >> 22) & 0x1) == 0)
8567                                                                {
8568                                                                  if (((word >> 23) & 0x1) == 0)
8569                                                                    {
8570                                                                      /* 33222222222211111111110000000000
8571                                                                         10987654321098765432109876543210
8572                                                                         000001x00010xxxx111100xxxxxxxxxx
8573                                                                         sqincb.  */
8574                                                                      return 1863;
8575                                                                    }
8576                                                                  else
8577                                                                    {
8578                                                                      /* 33222222222211111111110000000000
8579                                                                         10987654321098765432109876543210
8580                                                                         000001x01010xxxx111100xxxxxxxxxx
8581                                                                         sqincw.  */
8582                                                                      return 1875;
8583                                                                    }
8584                                                                }
8585                                                              else
8586                                                                {
8587                                                                  if (((word >> 23) & 0x1) == 0)
8588                                                                    {
8589                                                                      /* 33222222222211111111110000000000
8590                                                                         10987654321098765432109876543210
8591                                                                         000001x00110xxxx111100xxxxxxxxxx
8592                                                                         sqinch.  */
8593                                                                      return 1869;
8594                                                                    }
8595                                                                  else
8596                                                                    {
8597                                                                      /* 33222222222211111111110000000000
8598                                                                         10987654321098765432109876543210
8599                                                                         000001x01110xxxx111100xxxxxxxxxx
8600                                                                         sqincd.  */
8601                                                                      return 1866;
8602                                                                    }
8603                                                                }
8604                                                            }
8605                                                          else
8606                                                            {
8607                                                              if (((word >> 22) & 0x1) == 0)
8608                                                                {
8609                                                                  if (((word >> 23) & 0x1) == 0)
8610                                                                    {
8611                                                                      /* 33222222222211111111110000000000
8612                                                                         10987654321098765432109876543210
8613                                                                         000001x00011xxxx111100xxxxxxxxxx
8614                                                                         sqincb.  */
8615                                                                      return 1862;
8616                                                                    }
8617                                                                  else
8618                                                                    {
8619                                                                      /* 33222222222211111111110000000000
8620                                                                         10987654321098765432109876543210
8621                                                                         000001x01011xxxx111100xxxxxxxxxx
8622                                                                         sqincw.  */
8623                                                                      return 1874;
8624                                                                    }
8625                                                                }
8626                                                              else
8627                                                                {
8628                                                                  if (((word >> 23) & 0x1) == 0)
8629                                                                    {
8630                                                                      /* 33222222222211111111110000000000
8631                                                                         10987654321098765432109876543210
8632                                                                         000001x00111xxxx111100xxxxxxxxxx
8633                                                                         sqinch.  */
8634                                                                      return 1868;
8635                                                                    }
8636                                                                  else
8637                                                                    {
8638                                                                      /* 33222222222211111111110000000000
8639                                                                         10987654321098765432109876543210
8640                                                                         000001x01111xxxx111100xxxxxxxxxx
8641                                                                         sqincd.  */
8642                                                                      return 1865;
8643                                                                    }
8644                                                                }
8645                                                            }
8646                                                        }
8647                                                    }
8648                                                  else
8649                                                    {
8650                                                      if (((word >> 20) & 0x1) == 0)
8651                                                        {
8652                                                          if (((word >> 22) & 0x1) == 0)
8653                                                            {
8654                                                              if (((word >> 23) & 0x1) == 0)
8655                                                                {
8656                                                                  /* 33222222222211111111110000000000
8657                                                                     10987654321098765432109876543210
8658                                                                     000001x00010xxxx111x10xxxxxxxxxx
8659                                                                     sqdecb.  */
8660                                                                  return 1849;
8661                                                                }
8662                                                              else
8663                                                                {
8664                                                                  /* 33222222222211111111110000000000
8665                                                                     10987654321098765432109876543210
8666                                                                     000001x01010xxxx111x10xxxxxxxxxx
8667                                                                     sqdecw.  */
8668                                                                  return 1861;
8669                                                                }
8670                                                            }
8671                                                          else
8672                                                            {
8673                                                              if (((word >> 23) & 0x1) == 0)
8674                                                                {
8675                                                                  /* 33222222222211111111110000000000
8676                                                                     10987654321098765432109876543210
8677                                                                     000001x00110xxxx111x10xxxxxxxxxx
8678                                                                     sqdech.  */
8679                                                                  return 1855;
8680                                                                }
8681                                                              else
8682                                                                {
8683                                                                  /* 33222222222211111111110000000000
8684                                                                     10987654321098765432109876543210
8685                                                                     000001x01110xxxx111x10xxxxxxxxxx
8686                                                                     sqdecd.  */
8687                                                                  return 1852;
8688                                                                }
8689                                                            }
8690                                                        }
8691                                                      else
8692                                                        {
8693                                                          if (((word >> 22) & 0x1) == 0)
8694                                                            {
8695                                                              if (((word >> 23) & 0x1) == 0)
8696                                                                {
8697                                                                  /* 33222222222211111111110000000000
8698                                                                     10987654321098765432109876543210
8699                                                                     000001x00011xxxx111x10xxxxxxxxxx
8700                                                                     sqdecb.  */
8701                                                                  return 1848;
8702                                                                }
8703                                                              else
8704                                                                {
8705                                                                  /* 33222222222211111111110000000000
8706                                                                     10987654321098765432109876543210
8707                                                                     000001x01011xxxx111x10xxxxxxxxxx
8708                                                                     sqdecw.  */
8709                                                                  return 1860;
8710                                                                }
8711                                                            }
8712                                                          else
8713                                                            {
8714                                                              if (((word >> 23) & 0x1) == 0)
8715                                                                {
8716                                                                  /* 33222222222211111111110000000000
8717                                                                     10987654321098765432109876543210
8718                                                                     000001x00111xxxx111x10xxxxxxxxxx
8719                                                                     sqdech.  */
8720                                                                  return 1854;
8721                                                                }
8722                                                              else
8723                                                                {
8724                                                                  /* 33222222222211111111110000000000
8725                                                                     10987654321098765432109876543210
8726                                                                     000001x01111xxxx111x10xxxxxxxxxx
8727                                                                     sqdecd.  */
8728                                                                  return 1851;
8729                                                                }
8730                                                            }
8731                                                        }
8732                                                    }
8733                                                }
8734                                              else
8735                                                {
8736                                                  if (((word >> 11) & 0x1) == 0)
8737                                                    {
8738                                                      if (((word >> 12) & 0x1) == 0)
8739                                                        {
8740                                                          if (((word >> 22) & 0x1) == 0)
8741                                                            {
8742                                                              if (((word >> 23) & 0x1) == 0)
8743                                                                {
8744                                                                  /* 33222222222211111111110000000000
8745                                                                     10987654321098765432109876543210
8746                                                                     000001x0001xxxxx111001xxxxxxxxxx
8747                                                                     decb.  */
8748                                                                  return 1371;
8749                                                                }
8750                                                              else
8751                                                                {
8752                                                                  /* 33222222222211111111110000000000
8753                                                                     10987654321098765432109876543210
8754                                                                     000001x0101xxxxx111001xxxxxxxxxx
8755                                                                     decw.  */
8756                                                                  return 1379;
8757                                                                }
8758                                                            }
8759                                                          else
8760                                                            {
8761                                                              if (((word >> 23) & 0x1) == 0)
8762                                                                {
8763                                                                  /* 33222222222211111111110000000000
8764                                                                     10987654321098765432109876543210
8765                                                                     000001x0011xxxxx111001xxxxxxxxxx
8766                                                                     dech.  */
8767                                                                  return 1375;
8768                                                                }
8769                                                              else
8770                                                                {
8771                                                                  /* 33222222222211111111110000000000
8772                                                                     10987654321098765432109876543210
8773                                                                     000001x0111xxxxx111001xxxxxxxxxx
8774                                                                     decd.  */
8775                                                                  return 1373;
8776                                                                }
8777                                                            }
8778                                                        }
8779                                                      else
8780                                                        {
8781                                                          if (((word >> 20) & 0x1) == 0)
8782                                                            {
8783                                                              if (((word >> 22) & 0x1) == 0)
8784                                                                {
8785                                                                  if (((word >> 23) & 0x1) == 0)
8786                                                                    {
8787                                                                      /* 33222222222211111111110000000000
8788                                                                         10987654321098765432109876543210
8789                                                                         000001x00010xxxx111101xxxxxxxxxx
8790                                                                         uqincb.  */
8791                                                                      return 2010;
8792                                                                    }
8793                                                                  else
8794                                                                    {
8795                                                                      /* 33222222222211111111110000000000
8796                                                                         10987654321098765432109876543210
8797                                                                         000001x01010xxxx111101xxxxxxxxxx
8798                                                                         uqincw.  */
8799                                                                      return 2022;
8800                                                                    }
8801                                                                }
8802                                                              else
8803                                                                {
8804                                                                  if (((word >> 23) & 0x1) == 0)
8805                                                                    {
8806                                                                      /* 33222222222211111111110000000000
8807                                                                         10987654321098765432109876543210
8808                                                                         000001x00110xxxx111101xxxxxxxxxx
8809                                                                         uqinch.  */
8810                                                                      return 2016;
8811                                                                    }
8812                                                                  else
8813                                                                    {
8814                                                                      /* 33222222222211111111110000000000
8815                                                                         10987654321098765432109876543210
8816                                                                         000001x01110xxxx111101xxxxxxxxxx
8817                                                                         uqincd.  */
8818                                                                      return 2013;
8819                                                                    }
8820                                                                }
8821                                                            }
8822                                                          else
8823                                                            {
8824                                                              if (((word >> 22) & 0x1) == 0)
8825                                                                {
8826                                                                  if (((word >> 23) & 0x1) == 0)
8827                                                                    {
8828                                                                      /* 33222222222211111111110000000000
8829                                                                         10987654321098765432109876543210
8830                                                                         000001x00011xxxx111101xxxxxxxxxx
8831                                                                         uqincb.  */
8832                                                                      return 2011;
8833                                                                    }
8834                                                                  else
8835                                                                    {
8836                                                                      /* 33222222222211111111110000000000
8837                                                                         10987654321098765432109876543210
8838                                                                         000001x01011xxxx111101xxxxxxxxxx
8839                                                                         uqincw.  */
8840                                                                      return 2023;
8841                                                                    }
8842                                                                }
8843                                                              else
8844                                                                {
8845                                                                  if (((word >> 23) & 0x1) == 0)
8846                                                                    {
8847                                                                      /* 33222222222211111111110000000000
8848                                                                         10987654321098765432109876543210
8849                                                                         000001x00111xxxx111101xxxxxxxxxx
8850                                                                         uqinch.  */
8851                                                                      return 2017;
8852                                                                    }
8853                                                                  else
8854                                                                    {
8855                                                                      /* 33222222222211111111110000000000
8856                                                                         10987654321098765432109876543210
8857                                                                         000001x01111xxxx111101xxxxxxxxxx
8858                                                                         uqincd.  */
8859                                                                      return 2014;
8860                                                                    }
8861                                                                }
8862                                                            }
8863                                                        }
8864                                                    }
8865                                                  else
8866                                                    {
8867                                                      if (((word >> 20) & 0x1) == 0)
8868                                                        {
8869                                                          if (((word >> 22) & 0x1) == 0)
8870                                                            {
8871                                                              if (((word >> 23) & 0x1) == 0)
8872                                                                {
8873                                                                  /* 33222222222211111111110000000000
8874                                                                     10987654321098765432109876543210
8875                                                                     000001x00010xxxx111x11xxxxxxxxxx
8876                                                                     uqdecb.  */
8877                                                                  return 1996;
8878                                                                }
8879                                                              else
8880                                                                {
8881                                                                  /* 33222222222211111111110000000000
8882                                                                     10987654321098765432109876543210
8883                                                                     000001x01010xxxx111x11xxxxxxxxxx
8884                                                                     uqdecw.  */
8885                                                                  return 2008;
8886                                                                }
8887                                                            }
8888                                                          else
8889                                                            {
8890                                                              if (((word >> 23) & 0x1) == 0)
8891                                                                {
8892                                                                  /* 33222222222211111111110000000000
8893                                                                     10987654321098765432109876543210
8894                                                                     000001x00110xxxx111x11xxxxxxxxxx
8895                                                                     uqdech.  */
8896                                                                  return 2002;
8897                                                                }
8898                                                              else
8899                                                                {
8900                                                                  /* 33222222222211111111110000000000
8901                                                                     10987654321098765432109876543210
8902                                                                     000001x01110xxxx111x11xxxxxxxxxx
8903                                                                     uqdecd.  */
8904                                                                  return 1999;
8905                                                                }
8906                                                            }
8907                                                        }
8908                                                      else
8909                                                        {
8910                                                          if (((word >> 22) & 0x1) == 0)
8911                                                            {
8912                                                              if (((word >> 23) & 0x1) == 0)
8913                                                                {
8914                                                                  /* 33222222222211111111110000000000
8915                                                                     10987654321098765432109876543210
8916                                                                     000001x00011xxxx111x11xxxxxxxxxx
8917                                                                     uqdecb.  */
8918                                                                  return 1997;
8919                                                                }
8920                                                              else
8921                                                                {
8922                                                                  /* 33222222222211111111110000000000
8923                                                                     10987654321098765432109876543210
8924                                                                     000001x01011xxxx111x11xxxxxxxxxx
8925                                                                     uqdecw.  */
8926                                                                  return 2009;
8927                                                                }
8928                                                            }
8929                                                          else
8930                                                            {
8931                                                              if (((word >> 23) & 0x1) == 0)
8932                                                                {
8933                                                                  /* 33222222222211111111110000000000
8934                                                                     10987654321098765432109876543210
8935                                                                     000001x00111xxxx111x11xxxxxxxxxx
8936                                                                     uqdech.  */
8937                                                                  return 2003;
8938                                                                }
8939                                                              else
8940                                                                {
8941                                                                  /* 33222222222211111111110000000000
8942                                                                     10987654321098765432109876543210
8943                                                                     000001x01111xxxx111x11xxxxxxxxxx
8944                                                                     uqdecd.  */
8945                                                                  return 2000;
8946                                                                }
8947                                                            }
8948                                                        }
8949                                                    }
8950                                                }
8951                                            }
8952                                        }
8953                                      else
8954                                        {
8955                                          if (((word >> 22) & 0x1) == 0)
8956                                            {
8957                                              if (((word >> 21) & 0x1) == 0)
8958                                                {
8959                                                  if (((word >> 23) & 0x1) == 0)
8960                                                    {
8961                                                      /* 33222222222211111111110000000000
8962                                                         10987654321098765432109876543210
8963                                                         100001x0000xxxxx111xxxxxxxxxxxxx
8964                                                         prfb.  */
8965                                                      return 1782;
8966                                                    }
8967                                                  else
8968                                                    {
8969                                                      /* 33222222222211111111110000000000
8970                                                         10987654321098765432109876543210
8971                                                         100001x0100xxxxx111xxxxxxxxxxxxx
8972                                                         prfh.  */
8973                                                      return 1796;
8974                                                    }
8975                                                }
8976                                              else
8977                                                {
8978                                                  if (((word >> 23) & 0x1) == 0)
8979                                                    {
8980                                                      /* 33222222222211111111110000000000
8981                                                         10987654321098765432109876543210
8982                                                         100001x0001xxxxx111xxxxxxxxxxxxx
8983                                                         ldff1b.  */
8984                                                      return 1650;
8985                                                    }
8986                                                  else
8987                                                    {
8988                                                      /* 33222222222211111111110000000000
8989                                                         10987654321098765432109876543210
8990                                                         100001x0101xxxxx111xxxxxxxxxxxxx
8991                                                         ldff1h.  */
8992                                                      return 1671;
8993                                                    }
8994                                                }
8995                                            }
8996                                          else
8997                                            {
8998                                              if (((word >> 23) & 0x1) == 0)
8999                                                {
9000                                                  /* 33222222222211111111110000000000
9001                                                     10987654321098765432109876543210
9002                                                     100001x001xxxxxx111xxxxxxxxxxxxx
9003                                                     ld1rb.  */
9004                                                  return 1552;
9005                                                }
9006                                              else
9007                                                {
9008                                                  /* 33222222222211111111110000000000
9009                                                     10987654321098765432109876543210
9010                                                     100001x011xxxxxx111xxxxxxxxxxxxx
9011                                                     ld1rh.  */
9012                                                  return 1556;
9013                                                }
9014                                            }
9015                                        }
9016                                    }
9017                                  else
9018                                    {
9019                                      if (((word >> 21) & 0x1) == 0)
9020                                        {
9021                                          if (((word >> 22) & 0x1) == 0)
9022                                            {
9023                                              if (((word >> 23) & 0x1) == 0)
9024                                                {
9025                                                  /* 33222222222211111111110000000000
9026                                                     10987654321098765432109876543210
9027                                                     x10001x0000xxxxx111xxxxxxxxxxxxx
9028                                                     prfb.  */
9029                                                  return 1784;
9030                                                }
9031                                              else
9032                                                {
9033                                                  /* 33222222222211111111110000000000
9034                                                     10987654321098765432109876543210
9035                                                     x10001x0100xxxxx111xxxxxxxxxxxxx
9036                                                     prfh.  */
9037                                                  return 1798;
9038                                                }
9039                                            }
9040                                          else
9041                                            {
9042                                              if (((word >> 23) & 0x1) == 0)
9043                                                {
9044                                                  /* 33222222222211111111110000000000
9045                                                     10987654321098765432109876543210
9046                                                     x10001x0010xxxxx111xxxxxxxxxxxxx
9047                                                     ldff1b.  */
9048                                                  return 1649;
9049                                                }
9050                                              else
9051                                                {
9052                                                  /* 33222222222211111111110000000000
9053                                                     10987654321098765432109876543210
9054                                                     x10001x0110xxxxx111xxxxxxxxxxxxx
9055                                                     ldff1h.  */
9056                                                  return 1669;
9057                                                }
9058                                            }
9059                                        }
9060                                      else
9061                                        {
9062                                          if (((word >> 23) & 0x1) == 0)
9063                                            {
9064                                              if (((word >> 31) & 0x1) == 0)
9065                                                {
9066                                                  if (((word >> 10) & 0x1) == 0)
9067                                                    {
9068                                                      if (((word >> 11) & 0x1) == 0)
9069                                                        {
9070                                                          /* 33222222222211111111110000000000
9071                                                             10987654321098765432109876543210
9072                                                             010001x00x1xxxxx111x00xxxxxxxxxx
9073                                                             sqdmulh.  */
9074                                                          return 2193;
9075                                                        }
9076                                                      else
9077                                                        {
9078                                                          /* 33222222222211111111110000000000
9079                                                             10987654321098765432109876543210
9080                                                             010001x00x1xxxxx111x10xxxxxxxxxx
9081                                                             mul.  */
9082                                                          return 2120;
9083                                                        }
9084                                                    }
9085                                                  else
9086                                                    {
9087                                                      /* 33222222222211111111110000000000
9088                                                         10987654321098765432109876543210
9089                                                         010001x00x1xxxxx111xx1xxxxxxxxxx
9090                                                         sqrdmulh.  */
9091                                                      return 2215;
9092                                                    }
9093                                                }
9094                                              else
9095                                                {
9096                                                  if (((word >> 22) & 0x1) == 0)
9097                                                    {
9098                                                      /* 33222222222211111111110000000000
9099                                                         10987654321098765432109876543210
9100                                                         110001x0001xxxxx111xxxxxxxxxxxxx
9101                                                         ldff1b.  */
9102                                                      return 1651;
9103                                                    }
9104                                                  else
9105                                                    {
9106                                                      /* 33222222222211111111110000000000
9107                                                         10987654321098765432109876543210
9108                                                         110001x0011xxxxx111xxxxxxxxxxxxx
9109                                                         prfd.  */
9110                                                      return 1788;
9111                                                    }
9112                                                }
9113                                            }
9114                                          else
9115                                            {
9116                                              if (((word >> 22) & 0x1) == 0)
9117                                                {
9118                                                  if (((word >> 31) & 0x1) == 0)
9119                                                    {
9120                                                      if (((word >> 10) & 0x1) == 0)
9121                                                        {
9122                                                          if (((word >> 12) & 0x1) == 0)
9123                                                            {
9124                                                              /* 33222222222211111111110000000000
9125                                                                 10987654321098765432109876543210
9126                                                                 010001x0101xxxxx1110x0xxxxxxxxxx
9127                                                                 sqdmullb.  */
9128                                                              return 2197;
9129                                                            }
9130                                                          else
9131                                                            {
9132                                                              if (((word >> 11) & 0x1) == 0)
9133                                                                {
9134                                                                  /* 33222222222211111111110000000000
9135                                                                     10987654321098765432109876543210
9136                                                                     010001x0101xxxxx111100xxxxxxxxxx
9137                                                                     sqdmulh.  */
9138                                                                  return 2194;
9139                                                                }
9140                                                              else
9141                                                                {
9142                                                                  /* 33222222222211111111110000000000
9143                                                                     10987654321098765432109876543210
9144                                                                     010001x0101xxxxx111110xxxxxxxxxx
9145                                                                     mul.  */
9146                                                                  return 2121;
9147                                                                }
9148                                                            }
9149                                                        }
9150                                                      else
9151                                                        {
9152                                                          if (((word >> 12) & 0x1) == 0)
9153                                                            {
9154                                                              /* 33222222222211111111110000000000
9155                                                                 10987654321098765432109876543210
9156                                                                 010001x0101xxxxx1110x1xxxxxxxxxx
9157                                                                 sqdmullt.  */
9158                                                              return 2200;
9159                                                            }
9160                                                          else
9161                                                            {
9162                                                              /* 33222222222211111111110000000000
9163                                                                 10987654321098765432109876543210
9164                                                                 010001x0101xxxxx1111x1xxxxxxxxxx
9165                                                                 sqrdmulh.  */
9166                                                              return 2216;
9167                                                            }
9168                                                        }
9169                                                    }
9170                                                  else
9171                                                    {
9172                                                      /* 33222222222211111111110000000000
9173                                                         10987654321098765432109876543210
9174                                                         110001x0101xxxxx111xxxxxxxxxxxxx
9175                                                         ldff1h.  */
9176                                                      return 1672;
9177                                                    }
9178                                                }
9179                                              else
9180                                                {
9181                                                  if (((word >> 31) & 0x1) == 0)
9182                                                    {
9183                                                      if (((word >> 10) & 0x1) == 0)
9184                                                        {
9185                                                          if (((word >> 12) & 0x1) == 0)
9186                                                            {
9187                                                              /* 33222222222211111111110000000000
9188                                                                 10987654321098765432109876543210
9189                                                                 010001x0111xxxxx1110x0xxxxxxxxxx
9190                                                                 sqdmullb.  */
9191                                                              return 2198;
9192                                                            }
9193                                                          else
9194                                                            {
9195                                                              if (((word >> 11) & 0x1) == 0)
9196                                                                {
9197                                                                  /* 33222222222211111111110000000000
9198                                                                     10987654321098765432109876543210
9199                                                                     010001x0111xxxxx111100xxxxxxxxxx
9200                                                                     sqdmulh.  */
9201                                                                  return 2195;
9202                                                                }
9203                                                              else
9204                                                                {
9205                                                                  /* 33222222222211111111110000000000
9206                                                                     10987654321098765432109876543210
9207                                                                     010001x0111xxxxx111110xxxxxxxxxx
9208                                                                     mul.  */
9209                                                                  return 2122;
9210                                                                }
9211                                                            }
9212                                                        }
9213                                                      else
9214                                                        {
9215                                                          if (((word >> 12) & 0x1) == 0)
9216                                                            {
9217                                                              /* 33222222222211111111110000000000
9218                                                                 10987654321098765432109876543210
9219                                                                 010001x0111xxxxx1110x1xxxxxxxxxx
9220                                                                 sqdmullt.  */
9221                                                              return 2201;
9222                                                            }
9223                                                          else
9224                                                            {
9225                                                              /* 33222222222211111111110000000000
9226                                                                 10987654321098765432109876543210
9227                                                                 010001x0111xxxxx1111x1xxxxxxxxxx
9228                                                                 sqrdmulh.  */
9229                                                              return 2217;
9230                                                            }
9231                                                        }
9232                                                    }
9233                                                  else
9234                                                    {
9235                                                      /* 33222222222211111111110000000000
9236                                                         10987654321098765432109876543210
9237                                                         110001x0111xxxxx111xxxxxxxxxxxxx
9238                                                         ldff1h.  */
9239                                                      return 1670;
9240                                                    }
9241                                                }
9242                                            }
9243                                        }
9244                                    }
9245                                }
9246                            }
9247                        }
9248                    }
9249                  else
9250                    {
9251                      if (((word >> 21) & 0x1) == 0)
9252                        {
9253                          if (((word >> 15) & 0x1) == 0)
9254                            {
9255                              if (((word >> 30) & 0x1) == 0)
9256                                {
9257                                  if (((word >> 13) & 0x1) == 0)
9258                                    {
9259                                      if (((word >> 14) & 0x1) == 0)
9260                                        {
9261                                          if (((word >> 31) & 0x1) == 0)
9262                                            {
9263                                              if (((word >> 4) & 0x1) == 0)
9264                                                {
9265                                                  /* 33222222222211111111110000000000
9266                                                     10987654321098765432109876543210
9267                                                     001001x0xx0xxxxx000xxxxxxxx0xxxx
9268                                                     cmphs.  */
9269                                                  return 1344;
9270                                                }
9271                                              else
9272                                                {
9273                                                  /* 33222222222211111111110000000000
9274                                                     10987654321098765432109876543210
9275                                                     001001x0xx0xxxxx000xxxxxxxx1xxxx
9276                                                     cmphi.  */
9277                                                  return 1341;
9278                                                }
9279                                            }
9280                                          else
9281                                            {
9282                                              if (((word >> 23) & 0x1) == 0)
9283                                                {
9284                                                  /* 33222222222211111111110000000000
9285                                                     10987654321098765432109876543210
9286                                                     101001x00x0xxxxx000xxxxxxxxxxxxx
9287                                                     ld1rqb.  */
9288                                                  return 1558;
9289                                                }
9290                                              else
9291                                                {
9292                                                  /* 33222222222211111111110000000000
9293                                                     10987654321098765432109876543210
9294                                                     101001x01x0xxxxx000xxxxxxxxxxxxx
9295                                                     ld1rqh.  */
9296                                                  return 1562;
9297                                                }
9298                                            }
9299                                        }
9300                                      else
9301                                        {
9302                                          if (((word >> 31) & 0x1) == 0)
9303                                            {
9304                                              if (((word >> 4) & 0x1) == 0)
9305                                                {
9306                                                  /* 33222222222211111111110000000000
9307                                                     10987654321098765432109876543210
9308                                                     001001x0xx0xxxxx010xxxxxxxx0xxxx
9309                                                     cmpge.  */
9310                                                  return 1335;
9311                                                }
9312                                              else
9313                                                {
9314                                                  /* 33222222222211111111110000000000
9315                                                     10987654321098765432109876543210
9316                                                     001001x0xx0xxxxx010xxxxxxxx1xxxx
9317                                                     cmpgt.  */
9318                                                  return 1338;
9319                                                }
9320                                            }
9321                                          else
9322                                            {
9323                                              if (((word >> 22) & 0x1) == 0)
9324                                                {
9325                                                  if (((word >> 23) & 0x1) == 0)
9326                                                    {
9327                                                      /* 33222222222211111111110000000000
9328                                                         10987654321098765432109876543210
9329                                                         101001x0000xxxxx010xxxxxxxxxxxxx
9330                                                         ld1b.  */
9331                                                      return 1516;
9332                                                    }
9333                                                  else
9334                                                    {
9335                                                      /* 33222222222211111111110000000000
9336                                                         10987654321098765432109876543210
9337                                                         101001x0100xxxxx010xxxxxxxxxxxxx
9338                                                         ld1sw.  */
9339                                                      return 1596;
9340                                                    }
9341                                                }
9342                                              else
9343                                                {
9344                                                  if (((word >> 23) & 0x1) == 0)
9345                                                    {
9346                                                      /* 33222222222211111111110000000000
9347                                                         10987654321098765432109876543210
9348                                                         101001x0010xxxxx010xxxxxxxxxxxxx
9349                                                         ld1b.  */
9350                                                      return 1518;
9351                                                    }
9352                                                  else
9353                                                    {
9354                                                      /* 33222222222211111111110000000000
9355                                                         10987654321098765432109876543210
9356                                                         101001x0110xxxxx010xxxxxxxxxxxxx
9357                                                         ld1h.  */
9358                                                      return 1538;
9359                                                    }
9360                                                }
9361                                            }
9362                                        }
9363                                    }
9364                                  else
9365                                    {
9366                                      if (((word >> 14) & 0x1) == 0)
9367                                        {
9368                                          if (((word >> 31) & 0x1) == 0)
9369                                            {
9370                                              if (((word >> 4) & 0x1) == 0)
9371                                                {
9372                                                  /* 33222222222211111111110000000000
9373                                                     10987654321098765432109876543210
9374                                                     001001x0xx0xxxxx001xxxxxxxx0xxxx
9375                                                     cmpeq.  */
9376                                                  return 1332;
9377                                                }
9378                                              else
9379                                                {
9380                                                  /* 33222222222211111111110000000000
9381                                                     10987654321098765432109876543210
9382                                                     001001x0xx0xxxxx001xxxxxxxx1xxxx
9383                                                     cmpne.  */
9384                                                  return 1355;
9385                                                }
9386                                            }
9387                                          else
9388                                            {
9389                                              if (((word >> 23) & 0x1) == 0)
9390                                                {
9391                                                  /* 33222222222211111111110000000000
9392                                                     10987654321098765432109876543210
9393                                                     101001x00x0xxxxx001xxxxxxxxxxxxx
9394                                                     ld1rqb.  */
9395                                                  return 1557;
9396                                                }
9397                                              else
9398                                                {
9399                                                  /* 33222222222211111111110000000000
9400                                                     10987654321098765432109876543210
9401                                                     101001x01x0xxxxx001xxxxxxxxxxxxx
9402                                                     ld1rqh.  */
9403                                                  return 1561;
9404                                                }
9405                                            }
9406                                        }
9407                                      else
9408                                        {
9409                                          if (((word >> 31) & 0x1) == 0)
9410                                            {
9411                                              if (((word >> 4) & 0x1) == 0)
9412                                                {
9413                                                  /* 33222222222211111111110000000000
9414                                                     10987654321098765432109876543210
9415                                                     001001x0xx0xxxxx011xxxxxxxx0xxxx
9416                                                     cmplt.  */
9417                                                  return 1353;
9418                                                }
9419                                              else
9420                                                {
9421                                                  /* 33222222222211111111110000000000
9422                                                     10987654321098765432109876543210
9423                                                     001001x0xx0xxxxx011xxxxxxxx1xxxx
9424                                                     cmple.  */
9425                                                  return 1347;
9426                                                }
9427                                            }
9428                                          else
9429                                            {
9430                                              if (((word >> 22) & 0x1) == 0)
9431                                                {
9432                                                  if (((word >> 23) & 0x1) == 0)
9433                                                    {
9434                                                      /* 33222222222211111111110000000000
9435                                                         10987654321098765432109876543210
9436                                                         101001x0000xxxxx011xxxxxxxxxxxxx
9437                                                         ldff1b.  */
9438                                                      return 1640;
9439                                                    }
9440                                                  else
9441                                                    {
9442                                                      /* 33222222222211111111110000000000
9443                                                         10987654321098765432109876543210
9444                                                         101001x0100xxxxx011xxxxxxxxxxxxx
9445                                                         ldff1sw.  */
9446                                                      return 1696;
9447                                                    }
9448                                                }
9449                                              else
9450                                                {
9451                                                  if (((word >> 23) & 0x1) == 0)
9452                                                    {
9453                                                      /* 33222222222211111111110000000000
9454                                                         10987654321098765432109876543210
9455                                                         101001x0010xxxxx011xxxxxxxxxxxxx
9456                                                         ldff1b.  */
9457                                                      return 1644;
9458                                                    }
9459                                                  else
9460                                                    {
9461                                                      /* 33222222222211111111110000000000
9462                                                         10987654321098765432109876543210
9463                                                         101001x0110xxxxx011xxxxxxxxxxxxx
9464                                                         ldff1h.  */
9465                                                      return 1663;
9466                                                    }
9467                                                }
9468                                            }
9469                                        }
9470                                    }
9471                                }
9472                              else
9473                                {
9474                                  if (((word >> 31) & 0x1) == 0)
9475                                    {
9476                                      /* 33222222222211111111110000000000
9477                                         10987654321098765432109876543210
9478                                         011001x0xx0xxxxx0xxxxxxxxxxxxxxx
9479                                         fcmla.  */
9480                                      return 1401;
9481                                    }
9482                                  else
9483                                    {
9484                                      if (((word >> 13) & 0x1) == 0)
9485                                        {
9486                                          if (((word >> 22) & 0x1) == 0)
9487                                            {
9488                                              /* 33222222222211111111110000000000
9489                                                 10987654321098765432109876543210
9490                                                 111001x0x00xxxxx0x0xxxxxxxxxxxxx
9491                                                 st1b.  */
9492                                              return 1878;
9493                                            }
9494                                          else
9495                                            {
9496                                              if (((word >> 23) & 0x1) == 0)
9497                                                {
9498                                                  /* 33222222222211111111110000000000
9499                                                     10987654321098765432109876543210
9500                                                     111001x0010xxxxx0x0xxxxxxxxxxxxx
9501                                                     st1b.  */
9502                                                  return 1882;
9503                                                }
9504                                              else
9505                                                {
9506                                                  /* 33222222222211111111110000000000
9507                                                     10987654321098765432109876543210
9508                                                     111001x0110xxxxx0x0xxxxxxxxxxxxx
9509                                                     st1h.  */
9510                                                  return 1903;
9511                                                }
9512                                            }
9513                                        }
9514                                      else
9515                                        {
9516                                          if (((word >> 14) & 0x1) == 0)
9517                                            {
9518                                              if (((word >> 22) & 0x1) == 0)
9519                                                {
9520                                                  if (((word >> 23) & 0x1) == 0)
9521                                                    {
9522                                                      /* 33222222222211111111110000000000
9523                                                         10987654321098765432109876543210
9524                                                         111001x0000xxxxx001xxxxxxxxxxxxx
9525                                                         stnt1b.  */
9526                                                      return 2255;
9527                                                    }
9528                                                  else
9529                                                    {
9530                                                      /* 33222222222211111111110000000000
9531                                                         10987654321098765432109876543210
9532                                                         111001x0100xxxxx001xxxxxxxxxxxxx
9533                                                         stnt1h.  */
9534                                                      return 2258;
9535                                                    }
9536                                                }
9537                                              else
9538                                                {
9539                                                  if (((word >> 23) & 0x1) == 0)
9540                                                    {
9541                                                      /* 33222222222211111111110000000000
9542                                                         10987654321098765432109876543210
9543                                                         111001x0010xxxxx001xxxxxxxxxxxxx
9544                                                         stnt1b.  */
9545                                                      return 2254;
9546                                                    }
9547                                                  else
9548                                                    {
9549                                                      /* 33222222222211111111110000000000
9550                                                         10987654321098765432109876543210
9551                                                         111001x0110xxxxx001xxxxxxxxxxxxx
9552                                                         stnt1h.  */
9553                                                      return 2257;
9554                                                    }
9555                                                }
9556                                            }
9557                                          else
9558                                            {
9559                                              if (((word >> 22) & 0x1) == 0)
9560                                                {
9561                                                  if (((word >> 23) & 0x1) == 0)
9562                                                    {
9563                                                      /* 33222222222211111111110000000000
9564                                                         10987654321098765432109876543210
9565                                                         111001x0000xxxxx011xxxxxxxxxxxxx
9566                                                         stnt1b.  */
9567                                                      return 1948;
9568                                                    }
9569                                                  else
9570                                                    {
9571                                                      /* 33222222222211111111110000000000
9572                                                         10987654321098765432109876543210
9573                                                         111001x0100xxxxx011xxxxxxxxxxxxx
9574                                                         stnt1h.  */
9575                                                      return 1952;
9576                                                    }
9577                                                }
9578                                              else
9579                                                {
9580                                                  if (((word >> 23) & 0x1) == 0)
9581                                                    {
9582                                                      /* 33222222222211111111110000000000
9583                                                         10987654321098765432109876543210
9584                                                         111001x0010xxxxx011xxxxxxxxxxxxx
9585                                                         st3b.  */
9586                                                      return 1932;
9587                                                    }
9588                                                  else
9589                                                    {
9590                                                      /* 33222222222211111111110000000000
9591                                                         10987654321098765432109876543210
9592                                                         111001x0110xxxxx011xxxxxxxxxxxxx
9593                                                         st3h.  */
9594                                                      return 1936;
9595                                                    }
9596                                                }
9597                                            }
9598                                        }
9599                                    }
9600                                }
9601                            }
9602                          else
9603                            {
9604                              if (((word >> 13) & 0x1) == 0)
9605                                {
9606                                  if (((word >> 30) & 0x1) == 0)
9607                                    {
9608                                      if (((word >> 14) & 0x1) == 0)
9609                                        {
9610                                          if (((word >> 4) & 0x1) == 0)
9611                                            {
9612                                              /* 33222222222211111111110000000000
9613                                                 10987654321098765432109876543210
9614                                                 x01001x0xx0xxxxx100xxxxxxxx0xxxx
9615                                                 cmpge.  */
9616                                              return 1336;
9617                                            }
9618                                          else
9619                                            {
9620                                              /* 33222222222211111111110000000000
9621                                                 10987654321098765432109876543210
9622                                                 x01001x0xx0xxxxx100xxxxxxxx1xxxx
9623                                                 cmpgt.  */
9624                                              return 1339;
9625                                            }
9626                                        }
9627                                      else
9628                                        {
9629                                          if (((word >> 31) & 0x1) == 0)
9630                                            {
9631                                              if (((word >> 4) & 0x1) == 0)
9632                                                {
9633                                                  /* 33222222222211111111110000000000
9634                                                     10987654321098765432109876543210
9635                                                     001001x0xx0xxxxx110xxxxxxxx0xxxx
9636                                                     cmphs.  */
9637                                                  return 1345;
9638                                                }
9639                                              else
9640                                                {
9641                                                  /* 33222222222211111111110000000000
9642                                                     10987654321098765432109876543210
9643                                                     001001x0xx0xxxxx110xxxxxxxx1xxxx
9644                                                     cmphi.  */
9645                                                  return 1342;
9646                                                }
9647                                            }
9648                                          else
9649                                            {
9650                                              if (((word >> 22) & 0x1) == 0)
9651                                                {
9652                                                  if (((word >> 23) & 0x1) == 0)
9653                                                    {
9654                                                      /* 33222222222211111111110000000000
9655                                                         10987654321098765432109876543210
9656                                                         101001x0000xxxxx110xxxxxxxxxxxxx
9657                                                         ldnt1b.  */
9658                                                      return 1731;
9659                                                    }
9660                                                  else
9661                                                    {
9662                                                      /* 33222222222211111111110000000000
9663                                                         10987654321098765432109876543210
9664                                                         101001x0100xxxxx110xxxxxxxxxxxxx
9665                                                         ldnt1h.  */
9666                                                      return 1735;
9667                                                    }
9668                                                }
9669                                              else
9670                                                {
9671                                                  if (((word >> 23) & 0x1) == 0)
9672                                                    {
9673                                                      /* 33222222222211111111110000000000
9674                                                         10987654321098765432109876543210
9675                                                         101001x0010xxxxx110xxxxxxxxxxxxx
9676                                                         ld3b.  */
9677                                                      return 1623;
9678                                                    }
9679                                                  else
9680                                                    {
9681                                                      /* 33222222222211111111110000000000
9682                                                         10987654321098765432109876543210
9683                                                         101001x0110xxxxx110xxxxxxxxxxxxx
9684                                                         ld3h.  */
9685                                                      return 1627;
9686                                                    }
9687                                                }
9688                                            }
9689                                        }
9690                                    }
9691                                  else
9692                                    {
9693                                      if (((word >> 31) & 0x1) == 0)
9694                                        {
9695                                          if (((word >> 17) & 0x1) == 0)
9696                                            {
9697                                              if (((word >> 18) & 0x1) == 0)
9698                                                {
9699                                                  if (((word >> 20) & 0x1) == 0)
9700                                                    {
9701                                                      /* 33222222222211111111110000000000
9702                                                         10987654321098765432109876543210
9703                                                         011001x0xx00x00x1x0xxxxxxxxxxxxx
9704                                                         fcadd.  */
9705                                                      return 1400;
9706                                                    }
9707                                                  else
9708                                                    {
9709                                                      /* 33222222222211111111110000000000
9710                                                         10987654321098765432109876543210
9711                                                         011001x0xx01x00x1x0xxxxxxxxxxxxx
9712                                                         faddp.  */
9713                                                      return 2081;
9714                                                    }
9715                                                }
9716                                              else
9717                                                {
9718                                                  if (((word >> 16) & 0x1) == 0)
9719                                                    {
9720                                                      /* 33222222222211111111110000000000
9721                                                         10987654321098765432109876543210
9722                                                         011001x0xx0xx1001x0xxxxxxxxxxxxx
9723                                                         fmaxnmp.  */
9724                                                      return 2089;
9725                                                    }
9726                                                  else
9727                                                    {
9728                                                      /* 33222222222211111111110000000000
9729                                                         10987654321098765432109876543210
9730                                                         011001x0xx0xx1011x0xxxxxxxxxxxxx
9731                                                         fminnmp.  */
9732                                                      return 2091;
9733                                                    }
9734                                                }
9735                                            }
9736                                          else
9737                                            {
9738                                              if (((word >> 16) & 0x1) == 0)
9739                                                {
9740                                                  /* 33222222222211111111110000000000
9741                                                     10987654321098765432109876543210
9742                                                     011001x0xx0xxx101x0xxxxxxxxxxxxx
9743                                                     fmaxp.  */
9744                                                  return 2090;
9745                                                }
9746                                              else
9747                                                {
9748                                                  /* 33222222222211111111110000000000
9749                                                     10987654321098765432109876543210
9750                                                     011001x0xx0xxx111x0xxxxxxxxxxxxx
9751                                                     fminp.  */
9752                                                  return 2092;
9753                                                }
9754                                            }
9755                                        }
9756                                      else
9757                                        {
9758                                          if (((word >> 22) & 0x1) == 0)
9759                                            {
9760                                              if (((word >> 23) & 0x1) == 0)
9761                                                {
9762                                                  /* 33222222222211111111110000000000
9763                                                     10987654321098765432109876543210
9764                                                     111001x0000xxxxx1x0xxxxxxxxxxxxx
9765                                                     st1b.  */
9766                                                  return 1879;
9767                                                }
9768                                              else
9769                                                {
9770                                                  /* 33222222222211111111110000000000
9771                                                     10987654321098765432109876543210
9772                                                     111001x0100xxxxx1x0xxxxxxxxxxxxx
9773                                                     st1h.  */
9774                                                  return 1898;
9775                                                }
9776                                            }
9777                                          else
9778                                            {
9779                                              if (((word >> 23) & 0x1) == 0)
9780                                                {
9781                                                  /* 33222222222211111111110000000000
9782                                                     10987654321098765432109876543210
9783                                                     111001x0010xxxxx1x0xxxxxxxxxxxxx
9784                                                     st1b.  */
9785                                                  return 1883;
9786                                                }
9787                                              else
9788                                                {
9789                                                  /* 33222222222211111111110000000000
9790                                                     10987654321098765432109876543210
9791                                                     111001x0110xxxxx1x0xxxxxxxxxxxxx
9792                                                     st1h.  */
9793                                                  return 1904;
9794                                                }
9795                                            }
9796                                        }
9797                                    }
9798                                }
9799                              else
9800                                {
9801                                  if (((word >> 14) & 0x1) == 0)
9802                                    {
9803                                      if (((word >> 30) & 0x1) == 0)
9804                                        {
9805                                          if (((word >> 31) & 0x1) == 0)
9806                                            {
9807                                              if (((word >> 4) & 0x1) == 0)
9808                                                {
9809                                                  /* 33222222222211111111110000000000
9810                                                     10987654321098765432109876543210
9811                                                     001001x0xx0xxxxx101xxxxxxxx0xxxx
9812                                                     cmpeq.  */
9813                                                  return 1333;
9814                                                }
9815                                              else
9816                                                {
9817                                                  /* 33222222222211111111110000000000
9818                                                     10987654321098765432109876543210
9819                                                     001001x0xx0xxxxx101xxxxxxxx1xxxx
9820                                                     cmpne.  */
9821                                                  return 1356;
9822                                                }
9823                                            }
9824                                          else
9825                                            {
9826                                              if (((word >> 20) & 0x1) == 0)
9827                                                {
9828                                                  if (((word >> 22) & 0x1) == 0)
9829                                                    {
9830                                                      if (((word >> 23) & 0x1) == 0)
9831                                                        {
9832                                                          /* 33222222222211111111110000000000
9833                                                             10987654321098765432109876543210
9834                                                             101001x00000xxxx101xxxxxxxxxxxxx
9835                                                             ld1b.  */
9836                                                          return 1523;
9837                                                        }
9838                                                      else
9839                                                        {
9840                                                          /* 33222222222211111111110000000000
9841                                                             10987654321098765432109876543210
9842                                                             101001x01000xxxx101xxxxxxxxxxxxx
9843                                                             ld1sw.  */
9844                                                          return 1601;
9845                                                        }
9846                                                    }
9847                                                  else
9848                                                    {
9849                                                      if (((word >> 23) & 0x1) == 0)
9850                                                        {
9851                                                          /* 33222222222211111111110000000000
9852                                                             10987654321098765432109876543210
9853                                                             101001x00100xxxx101xxxxxxxxxxxxx
9854                                                             ld1b.  */
9855                                                          return 1525;
9856                                                        }
9857                                                      else
9858                                                        {
9859                                                          /* 33222222222211111111110000000000
9860                                                             10987654321098765432109876543210
9861                                                             101001x01100xxxx101xxxxxxxxxxxxx
9862                                                             ld1h.  */
9863                                                          return 1546;
9864                                                        }
9865                                                    }
9866                                                }
9867                                              else
9868                                                {
9869                                                  if (((word >> 22) & 0x1) == 0)
9870                                                    {
9871                                                      if (((word >> 23) & 0x1) == 0)
9872                                                        {
9873                                                          /* 33222222222211111111110000000000
9874                                                             10987654321098765432109876543210
9875                                                             101001x00001xxxx101xxxxxxxxxxxxx
9876                                                             ldnf1b.  */
9877                                                          return 1715;
9878                                                        }
9879                                                      else
9880                                                        {
9881                                                          /* 33222222222211111111110000000000
9882                                                             10987654321098765432109876543210
9883                                                             101001x01001xxxx101xxxxxxxxxxxxx
9884                                                             ldnf1sw.  */
9885                                                          return 1728;
9886                                                        }
9887                                                    }
9888                                                  else
9889                                                    {
9890                                                      if (((word >> 23) & 0x1) == 0)
9891                                                        {
9892                                                          /* 33222222222211111111110000000000
9893                                                             10987654321098765432109876543210
9894                                                             101001x00101xxxx101xxxxxxxxxxxxx
9895                                                             ldnf1b.  */
9896                                                          return 1717;
9897                                                        }
9898                                                      else
9899                                                        {
9900                                                          /* 33222222222211111111110000000000
9901                                                             10987654321098765432109876543210
9902                                                             101001x01101xxxx101xxxxxxxxxxxxx
9903                                                             ldnf1h.  */
9904                                                          return 1721;
9905                                                        }
9906                                                    }
9907                                                }
9908                                            }
9909                                        }
9910                                      else
9911                                        {
9912                                          if (((word >> 22) & 0x1) == 0)
9913                                            {
9914                                              if (((word >> 23) & 0x1) == 0)
9915                                                {
9916                                                  if (((word >> 31) & 0x1) == 0)
9917                                                    {
9918                                                      /* 33222222222211111111110000000000
9919                                                         10987654321098765432109876543210
9920                                                         011001x0000xxxxx101xxxxxxxxxxxxx
9921                                                         fcvtxnt.  */
9922                                                      return 2087;
9923                                                    }
9924                                                  else
9925                                                    {
9926                                                      /* 33222222222211111111110000000000
9927                                                         10987654321098765432109876543210
9928                                                         111001x0000xxxxx101xxxxxxxxxxxxx
9929                                                         st1b.  */
9930                                                      return 1880;
9931                                                    }
9932                                                }
9933                                              else
9934                                                {
9935                                                  if (((word >> 31) & 0x1) == 0)
9936                                                    {
9937                                                      if (((word >> 16) & 0x1) == 0)
9938                                                        {
9939                                                          if (((word >> 17) & 0x1) == 0)
9940                                                            {
9941                                                              /* 33222222222211111111110000000000
9942                                                                 10987654321098765432109876543210
9943                                                                 011001x0100xxx00101xxxxxxxxxxxxx
9944                                                                 fcvtnt.  */
9945                                                              return 2084;
9946                                                            }
9947                                                          else
9948                                                            {
9949                                                              /* 33222222222211111111110000000000
9950                                                                 10987654321098765432109876543210
9951                                                                 011001x0100xxx10101xxxxxxxxxxxxx
9952                                                                 bfcvtnt.  */
9953                                                              return 2499;
9954                                                            }
9955                                                        }
9956                                                      else
9957                                                        {
9958                                                          /* 33222222222211111111110000000000
9959                                                             10987654321098765432109876543210
9960                                                             011001x0100xxxx1101xxxxxxxxxxxxx
9961                                                             fcvtlt.  */
9962                                                          return 2082;
9963                                                        }
9964                                                    }
9965                                                  else
9966                                                    {
9967                                                      /* 33222222222211111111110000000000
9968                                                         10987654321098765432109876543210
9969                                                         111001x0100xxxxx101xxxxxxxxxxxxx
9970                                                         st1h.  */
9971                                                      return 1899;
9972                                                    }
9973                                                }
9974                                            }
9975                                          else
9976                                            {
9977                                              if (((word >> 23) & 0x1) == 0)
9978                                                {
9979                                                  /* 33222222222211111111110000000000
9980                                                     10987654321098765432109876543210
9981                                                     x11001x0010xxxxx101xxxxxxxxxxxxx
9982                                                     st1b.  */
9983                                                  return 1887;
9984                                                }
9985                                              else
9986                                                {
9987                                                  if (((word >> 31) & 0x1) == 0)
9988                                                    {
9989                                                      if (((word >> 16) & 0x1) == 0)
9990                                                        {
9991                                                          /* 33222222222211111111110000000000
9992                                                             10987654321098765432109876543210
9993                                                             011001x0110xxxx0101xxxxxxxxxxxxx
9994                                                             fcvtnt.  */
9995                                                          return 2085;
9996                                                        }
9997                                                      else
9998                                                        {
9999                                                          /* 33222222222211111111110000000000
10000                                                             10987654321098765432109876543210
10001                                                             011001x0110xxxx1101xxxxxxxxxxxxx
10002                                                             fcvtlt.  */
10003                                                          return 2083;
10004                                                        }
10005                                                    }
10006                                                  else
10007                                                    {
10008                                                      /* 33222222222211111111110000000000
10009                                                         10987654321098765432109876543210
10010                                                         111001x0110xxxxx101xxxxxxxxxxxxx
10011                                                         st1h.  */
10012                                                      return 1908;
10013                                                    }
10014                                                }
10015                                            }
10016                                        }
10017                                    }
10018                                  else
10019                                    {
10020                                      if (((word >> 30) & 0x1) == 0)
10021                                        {
10022                                          if (((word >> 31) & 0x1) == 0)
10023                                            {
10024                                              if (((word >> 4) & 0x1) == 0)
10025                                                {
10026                                                  /* 33222222222211111111110000000000
10027                                                     10987654321098765432109876543210
10028                                                     001001x0xx0xxxxx111xxxxxxxx0xxxx
10029                                                     cmplo.  */
10030                                                  return 1349;
10031                                                }
10032                                              else
10033                                                {
10034                                                  /* 33222222222211111111110000000000
10035                                                     10987654321098765432109876543210
10036                                                     001001x0xx0xxxxx111xxxxxxxx1xxxx
10037                                                     cmpls.  */
10038                                                  return 1351;
10039                                                }
10040                                            }
10041                                          else
10042                                            {
10043                                              if (((word >> 22) & 0x1) == 0)
10044                                                {
10045                                                  if (((word >> 23) & 0x1) == 0)
10046                                                    {
10047                                                      /* 33222222222211111111110000000000
10048                                                         10987654321098765432109876543210
10049                                                         101001x0000xxxxx111xxxxxxxxxxxxx
10050                                                         ldnt1b.  */
10051                                                      return 1732;
10052                                                    }
10053                                                  else
10054                                                    {
10055                                                      /* 33222222222211111111110000000000
10056                                                         10987654321098765432109876543210
10057                                                         101001x0100xxxxx111xxxxxxxxxxxxx
10058                                                         ldnt1h.  */
10059                                                      return 1736;
10060                                                    }
10061                                                }
10062                                              else
10063                                                {
10064                                                  if (((word >> 23) & 0x1) == 0)
10065                                                    {
10066                                                      /* 33222222222211111111110000000000
10067                                                         10987654321098765432109876543210
10068                                                         101001x0010xxxxx111xxxxxxxxxxxxx
10069                                                         ld3b.  */
10070                                                      return 1624;
10071                                                    }
10072                                                  else
10073                                                    {
10074                                                      /* 33222222222211111111110000000000
10075                                                         10987654321098765432109876543210
10076                                                         101001x0110xxxxx111xxxxxxxxxxxxx
10077                                                         ld3h.  */
10078                                                      return 1628;
10079                                                    }
10080                                                }
10081                                            }
10082                                        }
10083                                      else
10084                                        {
10085                                          if (((word >> 20) & 0x1) == 0)
10086                                            {
10087                                              if (((word >> 22) & 0x1) == 0)
10088                                                {
10089                                                  /* 33222222222211111111110000000000
10090                                                     10987654321098765432109876543210
10091                                                     x11001x0x000xxxx111xxxxxxxxxxxxx
10092                                                     st1b.  */
10093                                                  return 1885;
10094                                                }
10095                                              else
10096                                                {
10097                                                  if (((word >> 23) & 0x1) == 0)
10098                                                    {
10099                                                      /* 33222222222211111111110000000000
10100                                                         10987654321098765432109876543210
10101                                                         x11001x00100xxxx111xxxxxxxxxxxxx
10102                                                         st1b.  */
10103                                                      return 1888;
10104                                                    }
10105                                                  else
10106                                                    {
10107                                                      /* 33222222222211111111110000000000
10108                                                         10987654321098765432109876543210
10109                                                         x11001x01100xxxx111xxxxxxxxxxxxx
10110                                                         st1h.  */
10111                                                      return 1909;
10112                                                    }
10113                                                }
10114                                            }
10115                                          else
10116                                            {
10117                                              if (((word >> 22) & 0x1) == 0)
10118                                                {
10119                                                  if (((word >> 23) & 0x1) == 0)
10120                                                    {
10121                                                      /* 33222222222211111111110000000000
10122                                                         10987654321098765432109876543210
10123                                                         x11001x00001xxxx111xxxxxxxxxxxxx
10124                                                         stnt1b.  */
10125                                                      return 1949;
10126                                                    }
10127                                                  else
10128                                                    {
10129                                                      /* 33222222222211111111110000000000
10130                                                         10987654321098765432109876543210
10131                                                         x11001x01001xxxx111xxxxxxxxxxxxx
10132                                                         stnt1h.  */
10133                                                      return 1953;
10134                                                    }
10135                                                }
10136                                              else
10137                                                {
10138                                                  if (((word >> 23) & 0x1) == 0)
10139                                                    {
10140                                                      /* 33222222222211111111110000000000
10141                                                         10987654321098765432109876543210
10142                                                         x11001x00101xxxx111xxxxxxxxxxxxx
10143                                                         st3b.  */
10144                                                      return 1933;
10145                                                    }
10146                                                  else
10147                                                    {
10148                                                      /* 33222222222211111111110000000000
10149                                                         10987654321098765432109876543210
10150                                                         x11001x01101xxxx111xxxxxxxxxxxxx
10151                                                         st3h.  */
10152                                                      return 1937;
10153                                                    }
10154                                                }
10155                                            }
10156                                        }
10157                                    }
10158                                }
10159                            }
10160                        }
10161                      else
10162                        {
10163                          if (((word >> 13) & 0x1) == 0)
10164                            {
10165                              if (((word >> 30) & 0x1) == 0)
10166                                {
10167                                  if (((word >> 31) & 0x1) == 0)
10168                                    {
10169                                      if (((word >> 4) & 0x1) == 0)
10170                                        {
10171                                          /* 33222222222211111111110000000000
10172                                             10987654321098765432109876543210
10173                                             001001x0xx1xxxxxxx0xxxxxxxx0xxxx
10174                                             cmphs.  */
10175                                          return 1346;
10176                                        }
10177                                      else
10178                                        {
10179                                          /* 33222222222211111111110000000000
10180                                             10987654321098765432109876543210
10181                                             001001x0xx1xxxxxxx0xxxxxxxx1xxxx
10182                                             cmphi.  */
10183                                          return 1343;
10184                                        }
10185                                    }
10186                                  else
10187                                    {
10188                                      if (((word >> 14) & 0x1) == 0)
10189                                        {
10190                                          if (((word >> 23) & 0x1) == 0)
10191                                            {
10192                                              /* 33222222222211111111110000000000
10193                                                 10987654321098765432109876543210
10194                                                 101001x00x1xxxxxx00xxxxxxxxxxxxx
10195                                                 ld1rob.  */
10196                                              return 2475;
10197                                            }
10198                                          else
10199                                            {
10200                                              /* 33222222222211111111110000000000
10201                                                 10987654321098765432109876543210
10202                                                 101001x01x1xxxxxx00xxxxxxxxxxxxx
10203                                                 ld1roh.  */
10204                                              return 2476;
10205                                            }
10206                                        }
10207                                      else
10208                                        {
10209                                          if (((word >> 15) & 0x1) == 0)
10210                                            {
10211                                              if (((word >> 22) & 0x1) == 0)
10212                                                {
10213                                                  if (((word >> 23) & 0x1) == 0)
10214                                                    {
10215                                                      /* 33222222222211111111110000000000
10216                                                         10987654321098765432109876543210
10217                                                         101001x0001xxxxx010xxxxxxxxxxxxx
10218                                                         ld1b.  */
10219                                                      return 1517;
10220                                                    }
10221                                                  else
10222                                                    {
10223                                                      /* 33222222222211111111110000000000
10224                                                         10987654321098765432109876543210
10225                                                         101001x0101xxxxx010xxxxxxxxxxxxx
10226                                                         ld1h.  */
10227                                                      return 1537;
10228                                                    }
10229                                                }
10230                                              else
10231                                                {
10232                                                  if (((word >> 23) & 0x1) == 0)
10233                                                    {
10234                                                      /* 33222222222211111111110000000000
10235                                                         10987654321098765432109876543210
10236                                                         101001x0011xxxxx010xxxxxxxxxxxxx
10237                                                         ld1b.  */
10238                                                      return 1519;
10239                                                    }
10240                                                  else
10241                                                    {
10242                                                      /* 33222222222211111111110000000000
10243                                                         10987654321098765432109876543210
10244                                                         101001x0111xxxxx010xxxxxxxxxxxxx
10245                                                         ld1h.  */
10246                                                      return 1539;
10247                                                    }
10248                                                }
10249                                            }
10250                                          else
10251                                            {
10252                                              if (((word >> 22) & 0x1) == 0)
10253                                                {
10254                                                  if (((word >> 23) & 0x1) == 0)
10255                                                    {
10256                                                      /* 33222222222211111111110000000000
10257                                                         10987654321098765432109876543210
10258                                                         101001x0001xxxxx110xxxxxxxxxxxxx
10259                                                         ld2b.  */
10260                                                      return 1615;
10261                                                    }
10262                                                  else
10263                                                    {
10264                                                      /* 33222222222211111111110000000000
10265                                                         10987654321098765432109876543210
10266                                                         101001x0101xxxxx110xxxxxxxxxxxxx
10267                                                         ld2h.  */
10268                                                      return 1619;
10269                                                    }
10270                                                }
10271                                              else
10272                                                {
10273                                                  if (((word >> 23) & 0x1) == 0)
10274                                                    {
10275                                                      /* 33222222222211111111110000000000
10276                                                         10987654321098765432109876543210
10277                                                         101001x0011xxxxx110xxxxxxxxxxxxx
10278                                                         ld4b.  */
10279                                                      return 1631;
10280                                                    }
10281                                                  else
10282                                                    {
10283                                                      /* 33222222222211111111110000000000
10284                                                         10987654321098765432109876543210
10285                                                         101001x0111xxxxx110xxxxxxxxxxxxx
10286                                                         ld4h.  */
10287                                                      return 1635;
10288                                                    }
10289                                                }
10290                                            }
10291                                        }
10292                                    }
10293                                }
10294                              else
10295                                {
10296                                  if (((word >> 15) & 0x1) == 0)
10297                                    {
10298                                      if (((word >> 14) & 0x1) == 0)
10299                                        {
10300                                          if (((word >> 12) & 0x1) == 0)
10301                                            {
10302                                              if (((word >> 10) & 0x1) == 0)
10303                                                {
10304                                                  if (((word >> 23) & 0x1) == 0)
10305                                                    {
10306                                                      /* 33222222222211111111110000000000
10307                                                         10987654321098765432109876543210
10308                                                         x11001x00x1xxxxx0000x0xxxxxxxxxx
10309                                                         fmla.  */
10310                                                      return 1454;
10311                                                    }
10312                                                  else
10313                                                    {
10314                                                      if (((word >> 22) & 0x1) == 0)
10315                                                        {
10316                                                          /* 33222222222211111111110000000000
10317                                                             10987654321098765432109876543210
10318                                                             x11001x0101xxxxx0000x0xxxxxxxxxx
10319                                                             fmla.  */
10320                                                          return 1455;
10321                                                        }
10322                                                      else
10323                                                        {
10324                                                          /* 33222222222211111111110000000000
10325                                                             10987654321098765432109876543210
10326                                                             x11001x0111xxxxx0000x0xxxxxxxxxx
10327                                                             fmla.  */
10328                                                          return 1456;
10329                                                        }
10330                                                    }
10331                                                }
10332                                              else
10333                                                {
10334                                                  if (((word >> 23) & 0x1) == 0)
10335                                                    {
10336                                                      /* 33222222222211111111110000000000
10337                                                         10987654321098765432109876543210
10338                                                         x11001x00x1xxxxx0000x1xxxxxxxxxx
10339                                                         fmls.  */
10340                                                      return 1458;
10341                                                    }
10342                                                  else
10343                                                    {
10344                                                      if (((word >> 22) & 0x1) == 0)
10345                                                        {
10346                                                          /* 33222222222211111111110000000000
10347                                                             10987654321098765432109876543210
10348                                                             x11001x0101xxxxx0000x1xxxxxxxxxx
10349                                                             fmls.  */
10350                                                          return 1459;
10351                                                        }
10352                                                      else
10353                                                        {
10354                                                          /* 33222222222211111111110000000000
10355                                                             10987654321098765432109876543210
10356                                                             x11001x0111xxxxx0000x1xxxxxxxxxx
10357                                                             fmls.  */
10358                                                          return 1460;
10359                                                        }
10360                                                    }
10361                                                }
10362                                            }
10363                                          else
10364                                            {
10365                                              if (((word >> 22) & 0x1) == 0)
10366                                                {
10367                                                  /* 33222222222211111111110000000000
10368                                                     10987654321098765432109876543210
10369                                                     x11001x0x01xxxxx0001xxxxxxxxxxxx
10370                                                     fcmla.  */
10371                                                  return 1402;
10372                                                }
10373                                              else
10374                                                {
10375                                                  /* 33222222222211111111110000000000
10376                                                     10987654321098765432109876543210
10377                                                     x11001x0x11xxxxx0001xxxxxxxxxxxx
10378                                                     fcmla.  */
10379                                                  return 1403;
10380                                                }
10381                                            }
10382                                        }
10383                                      else
10384                                        {
10385                                          if (((word >> 22) & 0x1) == 0)
10386                                            {
10387                                              if (((word >> 23) & 0x1) == 0)
10388                                                {
10389                                                  /* 33222222222211111111110000000000
10390                                                     10987654321098765432109876543210
10391                                                     x11001x0001xxxxx010xxxxxxxxxxxxx
10392                                                     st1b.  */
10393                                                  return 1881;
10394                                                }
10395                                              else
10396                                                {
10397                                                  if (((word >> 31) & 0x1) == 0)
10398                                                    {
10399                                                      if (((word >> 10) & 0x1) == 0)
10400                                                        {
10401                                                          /* 33222222222211111111110000000000
10402                                                             10987654321098765432109876543210
10403                                                             011001x0101xxxxx010xx0xxxxxxxxxx
10404                                                             fmlalb.  */
10405                                                          return 2093;
10406                                                        }
10407                                                      else
10408                                                        {
10409                                                          /* 33222222222211111111110000000000
10410                                                             10987654321098765432109876543210
10411                                                             011001x0101xxxxx010xx1xxxxxxxxxx
10412                                                             fmlalt.  */
10413                                                          return 2095;
10414                                                        }
10415                                                    }
10416                                                  else
10417                                                    {
10418                                                      /* 33222222222211111111110000000000
10419                                                         10987654321098765432109876543210
10420                                                         111001x0101xxxxx010xxxxxxxxxxxxx
10421                                                         st1h.  */
10422                                                      return 1900;
10423                                                    }
10424                                                }
10425                                            }
10426                                          else
10427                                            {
10428                                              if (((word >> 23) & 0x1) == 0)
10429                                                {
10430                                                  if (((word >> 31) & 0x1) == 0)
10431                                                    {
10432                                                      /* 33222222222211111111110000000000
10433                                                         10987654321098765432109876543210
10434                                                         011001x0011xxxxx010xxxxxxxxxxxxx
10435                                                         bfdot.  */
10436                                                      return 2496;
10437                                                    }
10438                                                  else
10439                                                    {
10440                                                      /* 33222222222211111111110000000000
10441                                                         10987654321098765432109876543210
10442                                                         111001x0011xxxxx010xxxxxxxxxxxxx
10443                                                         st1b.  */
10444                                                      return 1884;
10445                                                    }
10446                                                }
10447                                              else
10448                                                {
10449                                                  if (((word >> 31) & 0x1) == 0)
10450                                                    {
10451                                                      if (((word >> 10) & 0x1) == 0)
10452                                                        {
10453                                                          /* 33222222222211111111110000000000
10454                                                             10987654321098765432109876543210
10455                                                             011001x0111xxxxx010xx0xxxxxxxxxx
10456                                                             bfmlalb.  */
10457                                                          return 2503;
10458                                                        }
10459                                                      else
10460                                                        {
10461                                                          /* 33222222222211111111110000000000
10462                                                             10987654321098765432109876543210
10463                                                             011001x0111xxxxx010xx1xxxxxxxxxx
10464                                                             bfmlalt.  */
10465                                                          return 2502;
10466                                                        }
10467                                                    }
10468                                                  else
10469                                                    {
10470                                                      /* 33222222222211111111110000000000
10471                                                         10987654321098765432109876543210
10472                                                         111001x0111xxxxx010xxxxxxxxxxxxx
10473                                                         st1h.  */
10474                                                      return 1905;
10475                                                    }
10476                                                }
10477                                            }
10478                                        }
10479                                    }
10480                                  else
10481                                    {
10482                                      if (((word >> 22) & 0x1) == 0)
10483                                        {
10484                                          if (((word >> 31) & 0x1) == 0)
10485                                            {
10486                                              if (((word >> 10) & 0x1) == 0)
10487                                                {
10488                                                  /* 33222222222211111111110000000000
10489                                                     10987654321098765432109876543210
10490                                                     011001x0x01xxxxx1x0xx0xxxxxxxxxx
10491                                                     fmlalb.  */
10492                                                  return 2094;
10493                                                }
10494                                              else
10495                                                {
10496                                                  /* 33222222222211111111110000000000
10497                                                     10987654321098765432109876543210
10498                                                     011001x0x01xxxxx1x0xx1xxxxxxxxxx
10499                                                     fmlalt.  */
10500                                                  return 2096;
10501                                                }
10502                                            }
10503                                          else
10504                                            {
10505                                              /* 33222222222211111111110000000000
10506                                                 10987654321098765432109876543210
10507                                                 111001x0x01xxxxx1x0xxxxxxxxxxxxx
10508                                                 st1h.  */
10509                                              return 1901;
10510                                            }
10511                                        }
10512                                      else
10513                                        {
10514                                          if (((word >> 23) & 0x1) == 0)
10515                                            {
10516                                              /* 33222222222211111111110000000000
10517                                                 10987654321098765432109876543210
10518                                                 x11001x0011xxxxx1x0xxxxxxxxxxxxx
10519                                                 bfdot.  */
10520                                              return 2495;
10521                                            }
10522                                          else
10523                                            {
10524                                              if (((word >> 31) & 0x1) == 0)
10525                                                {
10526                                                  if (((word >> 10) & 0x1) == 0)
10527                                                    {
10528                                                      /* 33222222222211111111110000000000
10529                                                         10987654321098765432109876543210
10530                                                         011001x0111xxxxx1x0xx0xxxxxxxxxx
10531                                                         bfmlalb.  */
10532                                                      return 2501;
10533                                                    }
10534                                                  else
10535                                                    {
10536                                                      /* 33222222222211111111110000000000
10537                                                         10987654321098765432109876543210
10538                                                         011001x0111xxxxx1x0xx1xxxxxxxxxx
10539                                                         bfmlalt.  */
10540                                                      return 2500;
10541                                                    }
10542                                                }
10543                                              else
10544                                                {
10545                                                  /* 33222222222211111111110000000000
10546                                                     10987654321098765432109876543210
10547                                                     111001x0111xxxxx1x0xxxxxxxxxxxxx
10548                                                     st1h.  */
10549                                                  return 1906;
10550                                                }
10551                                            }
10552                                        }
10553                                    }
10554                                }
10555                            }
10556                          else
10557                            {
10558                              if (((word >> 30) & 0x1) == 0)
10559                                {
10560                                  if (((word >> 31) & 0x1) == 0)
10561                                    {
10562                                      if (((word >> 4) & 0x1) == 0)
10563                                        {
10564                                          /* 33222222222211111111110000000000
10565                                             10987654321098765432109876543210
10566                                             001001x0xx1xxxxxxx1xxxxxxxx0xxxx
10567                                             cmplo.  */
10568                                          return 1350;
10569                                        }
10570                                      else
10571                                        {
10572                                          /* 33222222222211111111110000000000
10573                                             10987654321098765432109876543210
10574                                             001001x0xx1xxxxxxx1xxxxxxxx1xxxx
10575                                             cmpls.  */
10576                                          return 1352;
10577                                        }
10578                                    }
10579                                  else
10580                                    {
10581                                      if (((word >> 14) & 0x1) == 0)
10582                                        {
10583                                          if (((word >> 15) & 0x1) == 0)
10584                                            {
10585                                              if (((word >> 23) & 0x1) == 0)
10586                                                {
10587                                                  /* 33222222222211111111110000000000
10588                                                     10987654321098765432109876543210
10589                                                     101001x00x1xxxxx001xxxxxxxxxxxxx
10590                                                     ld1rob.  */
10591                                                  return 2479;
10592                                                }
10593                                              else
10594                                                {
10595                                                  /* 33222222222211111111110000000000
10596                                                     10987654321098765432109876543210
10597                                                     101001x01x1xxxxx001xxxxxxxxxxxxx
10598                                                     ld1roh.  */
10599                                                  return 2480;
10600                                                }
10601                                            }
10602                                          else
10603                                            {
10604                                              if (((word >> 20) & 0x1) == 0)
10605                                                {
10606                                                  if (((word >> 22) & 0x1) == 0)
10607                                                    {
10608                                                      if (((word >> 23) & 0x1) == 0)
10609                                                        {
10610                                                          /* 33222222222211111111110000000000
10611                                                             10987654321098765432109876543210
10612                                                             101001x00010xxxx101xxxxxxxxxxxxx
10613                                                             ld1b.  */
10614                                                          return 1524;
10615                                                        }
10616                                                      else
10617                                                        {
10618                                                          /* 33222222222211111111110000000000
10619                                                             10987654321098765432109876543210
10620                                                             101001x01010xxxx101xxxxxxxxxxxxx
10621                                                             ld1h.  */
10622                                                          return 1545;
10623                                                        }
10624                                                    }
10625                                                  else
10626                                                    {
10627                                                      if (((word >> 23) & 0x1) == 0)
10628                                                        {
10629                                                          /* 33222222222211111111110000000000
10630                                                             10987654321098765432109876543210
10631                                                             101001x00110xxxx101xxxxxxxxxxxxx
10632                                                             ld1b.  */
10633                                                          return 1526;
10634                                                        }
10635                                                      else
10636                                                        {
10637                                                          /* 33222222222211111111110000000000
10638                                                             10987654321098765432109876543210
10639                                                             101001x01110xxxx101xxxxxxxxxxxxx
10640                                                             ld1h.  */
10641                                                          return 1547;
10642                                                        }
10643                                                    }
10644                                                }
10645                                              else
10646                                                {
10647                                                  if (((word >> 22) & 0x1) == 0)
10648                                                    {
10649                                                      if (((word >> 23) & 0x1) == 0)
10650                                                        {
10651                                                          /* 33222222222211111111110000000000
10652                                                             10987654321098765432109876543210
10653                                                             101001x00011xxxx101xxxxxxxxxxxxx
10654                                                             ldnf1b.  */
10655                                                          return 1716;
10656                                                        }
10657                                                      else
10658                                                        {
10659                                                          /* 33222222222211111111110000000000
10660                                                             10987654321098765432109876543210
10661                                                             101001x01011xxxx101xxxxxxxxxxxxx
10662                                                             ldnf1h.  */
10663                                                          return 1720;
10664                                                        }
10665                                                    }
10666                                                  else
10667                                                    {
10668                                                      if (((word >> 23) & 0x1) == 0)
10669                                                        {
10670                                                          /* 33222222222211111111110000000000
10671                                                             10987654321098765432109876543210
10672                                                             101001x00111xxxx101xxxxxxxxxxxxx
10673                                                             ldnf1b.  */
10674                                                          return 1718;
10675                                                        }
10676                                                      else
10677                                                        {
10678                                                          /* 33222222222211111111110000000000
10679                                                             10987654321098765432109876543210
10680                                                             101001x01111xxxx101xxxxxxxxxxxxx
10681                                                             ldnf1h.  */
10682                                                          return 1722;
10683                                                        }
10684                                                    }
10685                                                }
10686                                            }
10687                                        }
10688                                      else
10689                                        {
10690                                          if (((word >> 15) & 0x1) == 0)
10691                                            {
10692                                              if (((word >> 22) & 0x1) == 0)
10693                                                {
10694                                                  if (((word >> 23) & 0x1) == 0)
10695                                                    {
10696                                                      /* 33222222222211111111110000000000
10697                                                         10987654321098765432109876543210
10698                                                         101001x0001xxxxx011xxxxxxxxxxxxx
10699                                                         ldff1b.  */
10700                                                      return 1642;
10701                                                    }
10702                                                  else
10703                                                    {
10704                                                      /* 33222222222211111111110000000000
10705                                                         10987654321098765432109876543210
10706                                                         101001x0101xxxxx011xxxxxxxxxxxxx
10707                                                         ldff1h.  */
10708                                                      return 1661;
10709                                                    }
10710                                                }
10711                                              else
10712                                                {
10713                                                  if (((word >> 23) & 0x1) == 0)
10714                                                    {
10715                                                      /* 33222222222211111111110000000000
10716                                                         10987654321098765432109876543210
10717                                                         101001x0011xxxxx011xxxxxxxxxxxxx
10718                                                         ldff1b.  */
10719                                                      return 1646;
10720                                                    }
10721                                                  else
10722                                                    {
10723                                                      /* 33222222222211111111110000000000
10724                                                         10987654321098765432109876543210
10725                                                         101001x0111xxxxx011xxxxxxxxxxxxx
10726                                                         ldff1h.  */
10727                                                      return 1665;
10728                                                    }
10729                                                }
10730                                            }
10731                                          else
10732                                            {
10733                                              if (((word >> 22) & 0x1) == 0)
10734                                                {
10735                                                  if (((word >> 23) & 0x1) == 0)
10736                                                    {
10737                                                      /* 33222222222211111111110000000000
10738                                                         10987654321098765432109876543210
10739                                                         101001x0001xxxxx111xxxxxxxxxxxxx
10740                                                         ld2b.  */
10741                                                      return 1616;
10742                                                    }
10743                                                  else
10744                                                    {
10745                                                      /* 33222222222211111111110000000000
10746                                                         10987654321098765432109876543210
10747                                                         101001x0101xxxxx111xxxxxxxxxxxxx
10748                                                         ld2h.  */
10749                                                      return 1620;
10750                                                    }
10751                                                }
10752                                              else
10753                                                {
10754                                                  if (((word >> 23) & 0x1) == 0)
10755                                                    {
10756                                                      /* 33222222222211111111110000000000
10757                                                         10987654321098765432109876543210
10758                                                         101001x0011xxxxx111xxxxxxxxxxxxx
10759                                                         ld4b.  */
10760                                                      return 1632;
10761                                                    }
10762                                                  else
10763                                                    {
10764                                                      /* 33222222222211111111110000000000
10765                                                         10987654321098765432109876543210
10766                                                         101001x0111xxxxx111xxxxxxxxxxxxx
10767                                                         ld4h.  */
10768                                                      return 1636;
10769                                                    }
10770                                                }
10771                                            }
10772                                        }
10773                                    }
10774                                }
10775                              else
10776                                {
10777                                  if (((word >> 14) & 0x1) == 0)
10778                                    {
10779                                      if (((word >> 15) & 0x1) == 0)
10780                                        {
10781                                          if (((word >> 23) & 0x1) == 0)
10782                                            {
10783                                              /* 33222222222211111111110000000000
10784                                                 10987654321098765432109876543210
10785                                                 x11001x00x1xxxxx001xxxxxxxxxxxxx
10786                                                 fmul.  */
10787                                              return 1465;
10788                                            }
10789                                          else
10790                                            {
10791                                              if (((word >> 22) & 0x1) == 0)
10792                                                {
10793                                                  /* 33222222222211111111110000000000
10794                                                     10987654321098765432109876543210
10795                                                     x11001x0101xxxxx001xxxxxxxxxxxxx
10796                                                     fmul.  */
10797                                                  return 1466;
10798                                                }
10799                                              else
10800                                                {
10801                                                  /* 33222222222211111111110000000000
10802                                                     10987654321098765432109876543210
10803                                                     x11001x0111xxxxx001xxxxxxxxxxxxx
10804                                                     fmul.  */
10805                                                  return 1467;
10806                                                }
10807                                            }
10808                                        }
10809                                      else
10810                                        {
10811                                          if (((word >> 22) & 0x1) == 0)
10812                                            {
10813                                              if (((word >> 31) & 0x1) == 0)
10814                                                {
10815                                                  if (((word >> 10) & 0x1) == 0)
10816                                                    {
10817                                                      /* 33222222222211111111110000000000
10818                                                         10987654321098765432109876543210
10819                                                         011001x0x01xxxxx101xx0xxxxxxxxxx
10820                                                         fmlslb.  */
10821                                                      return 2098;
10822                                                    }
10823                                                  else
10824                                                    {
10825                                                      /* 33222222222211111111110000000000
10826                                                         10987654321098765432109876543210
10827                                                         011001x0x01xxxxx101xx1xxxxxxxxxx
10828                                                         fmlslt.  */
10829                                                      return 2100;
10830                                                    }
10831                                                }
10832                                              else
10833                                                {
10834                                                  /* 33222222222211111111110000000000
10835                                                     10987654321098765432109876543210
10836                                                     111001x0x01xxxxx101xxxxxxxxxxxxx
10837                                                     st1h.  */
10838                                                  return 1902;
10839                                                }
10840                                            }
10841                                          else
10842                                            {
10843                                              if (((word >> 23) & 0x1) == 0)
10844                                                {
10845                                                  /* 33222222222211111111110000000000
10846                                                     10987654321098765432109876543210
10847                                                     x11001x0011xxxxx101xxxxxxxxxxxxx
10848                                                     st1b.  */
10849                                                  return 1889;
10850                                                }
10851                                              else
10852                                                {
10853                                                  /* 33222222222211111111110000000000
10854                                                     10987654321098765432109876543210
10855                                                     x11001x0111xxxxx101xxxxxxxxxxxxx
10856                                                     st1h.  */
10857                                                  return 1910;
10858                                                }
10859                                            }
10860                                        }
10861                                    }
10862                                  else
10863                                    {
10864                                      if (((word >> 15) & 0x1) == 0)
10865                                        {
10866                                          if (((word >> 22) & 0x1) == 0)
10867                                            {
10868                                              if (((word >> 23) & 0x1) == 0)
10869                                                {
10870                                                  /* 33222222222211111111110000000000
10871                                                     10987654321098765432109876543210
10872                                                     x11001x0001xxxxx011xxxxxxxxxxxxx
10873                                                     st2b.  */
10874                                                  return 1924;
10875                                                }
10876                                              else
10877                                                {
10878                                                  if (((word >> 31) & 0x1) == 0)
10879                                                    {
10880                                                      if (((word >> 10) & 0x1) == 0)
10881                                                        {
10882                                                          /* 33222222222211111111110000000000
10883                                                             10987654321098765432109876543210
10884                                                             011001x0101xxxxx011xx0xxxxxxxxxx
10885                                                             fmlslb.  */
10886                                                          return 2097;
10887                                                        }
10888                                                      else
10889                                                        {
10890                                                          /* 33222222222211111111110000000000
10891                                                             10987654321098765432109876543210
10892                                                             011001x0101xxxxx011xx1xxxxxxxxxx
10893                                                             fmlslt.  */
10894                                                          return 2099;
10895                                                        }
10896                                                    }
10897                                                  else
10898                                                    {
10899                                                      /* 33222222222211111111110000000000
10900                                                         10987654321098765432109876543210
10901                                                         111001x0101xxxxx011xxxxxxxxxxxxx
10902                                                         st2h.  */
10903                                                      return 1928;
10904                                                    }
10905                                                }
10906                                            }
10907                                          else
10908                                            {
10909                                              if (((word >> 23) & 0x1) == 0)
10910                                                {
10911                                                  /* 33222222222211111111110000000000
10912                                                     10987654321098765432109876543210
10913                                                     x11001x0011xxxxx011xxxxxxxxxxxxx
10914                                                     st4b.  */
10915                                                  return 1940;
10916                                                }
10917                                              else
10918                                                {
10919                                                  /* 33222222222211111111110000000000
10920                                                     10987654321098765432109876543210
10921                                                     x11001x0111xxxxx011xxxxxxxxxxxxx
10922                                                     st4h.  */
10923                                                  return 1944;
10924                                                }
10925                                            }
10926                                        }
10927                                      else
10928                                        {
10929                                          if (((word >> 22) & 0x1) == 0)
10930                                            {
10931                                              if (((word >> 23) & 0x1) == 0)
10932                                                {
10933                                                  if (((word >> 20) & 0x1) == 0)
10934                                                    {
10935                                                      /* 33222222222211111111110000000000
10936                                                         10987654321098765432109876543210
10937                                                         x11001x00010xxxx111xxxxxxxxxxxxx
10938                                                         st1b.  */
10939                                                      return 1886;
10940                                                    }
10941                                                  else
10942                                                    {
10943                                                      /* 33222222222211111111110000000000
10944                                                         10987654321098765432109876543210
10945                                                         x11001x00011xxxx111xxxxxxxxxxxxx
10946                                                         st2b.  */
10947                                                      return 1925;
10948                                                    }
10949                                                }
10950                                              else
10951                                                {
10952                                                  if (((word >> 31) & 0x1) == 0)
10953                                                    {
10954                                                      /* 33222222222211111111110000000000
10955                                                         10987654321098765432109876543210
10956                                                         011001x0101xxxxx111xxxxxxxxxxxxx
10957                                                         fmmla.  */
10958                                                      return 2473;
10959                                                    }
10960                                                  else
10961                                                    {
10962                                                      if (((word >> 20) & 0x1) == 0)
10963                                                        {
10964                                                          /* 33222222222211111111110000000000
10965                                                             10987654321098765432109876543210
10966                                                             111001x01010xxxx111xxxxxxxxxxxxx
10967                                                             st1h.  */
10968                                                          return 1907;
10969                                                        }
10970                                                      else
10971                                                        {
10972                                                          /* 33222222222211111111110000000000
10973                                                             10987654321098765432109876543210
10974                                                             111001x01011xxxx111xxxxxxxxxxxxx
10975                                                             st2h.  */
10976                                                          return 1929;
10977                                                        }
10978                                                    }
10979                                                }
10980                                            }
10981                                          else
10982                                            {
10983                                              if (((word >> 23) & 0x1) == 0)
10984                                                {
10985                                                  if (((word >> 31) & 0x1) == 0)
10986                                                    {
10987                                                      /* 33222222222211111111110000000000
10988                                                         10987654321098765432109876543210
10989                                                         011001x0011xxxxx111xxxxxxxxxxxxx
10990                                                         bfmmla.  */
10991                                                      return 2497;
10992                                                    }
10993                                                  else
10994                                                    {
10995                                                      if (((word >> 20) & 0x1) == 0)
10996                                                        {
10997                                                          /* 33222222222211111111110000000000
10998                                                             10987654321098765432109876543210
10999                                                             111001x00110xxxx111xxxxxxxxxxxxx
11000                                                             st1b.  */
11001                                                          return 1890;
11002                                                        }
11003                                                      else
11004                                                        {
11005                                                          /* 33222222222211111111110000000000
11006                                                             10987654321098765432109876543210
11007                                                             111001x00111xxxx111xxxxxxxxxxxxx
11008                                                             st4b.  */
11009                                                          return 1941;
11010                                                        }
11011                                                    }
11012                                                }
11013                                              else
11014                                                {
11015                                                  if (((word >> 31) & 0x1) == 0)
11016                                                    {
11017                                                      /* 33222222222211111111110000000000
11018                                                         10987654321098765432109876543210
11019                                                         011001x0111xxxxx111xxxxxxxxxxxxx
11020                                                         fmmla.  */
11021                                                      return 2474;
11022                                                    }
11023                                                  else
11024                                                    {
11025                                                      if (((word >> 20) & 0x1) == 0)
11026                                                        {
11027                                                          /* 33222222222211111111110000000000
11028                                                             10987654321098765432109876543210
11029                                                             111001x01110xxxx111xxxxxxxxxxxxx
11030                                                             st1h.  */
11031                                                          return 1911;
11032                                                        }
11033                                                      else
11034                                                        {
11035                                                          /* 33222222222211111111110000000000
11036                                                             10987654321098765432109876543210
11037                                                             111001x01111xxxx111xxxxxxxxxxxxx
11038                                                             st4h.  */
11039                                                          return 1945;
11040                                                        }
11041                                                    }
11042                                                }
11043                                            }
11044                                        }
11045                                    }
11046                                }
11047                            }
11048                        }
11049                    }
11050                }
11051              else
11052                {
11053                  if (((word >> 29) & 0x1) == 0)
11054                    {
11055                      if (((word >> 30) & 0x1) == 0)
11056                        {
11057                          if (((word >> 31) & 0x1) == 0)
11058                            {
11059                              if (((word >> 21) & 0x1) == 0)
11060                                {
11061                                  if (((word >> 20) & 0x1) == 0)
11062                                    {
11063                                      if (((word >> 22) & 0x1) == 0)
11064                                        {
11065                                          if (((word >> 23) & 0x1) == 0)
11066                                            {
11067                                              /* 33222222222211111111110000000000
11068                                                 10987654321098765432109876543210
11069                                                 000001x10000xxxxxxxxxxxxxxxxxxxx
11070                                                 orr.  */
11071                                              return 1770;
11072                                            }
11073                                          else
11074                                            {
11075                                              /* 33222222222211111111110000000000
11076                                                 10987654321098765432109876543210
11077                                                 000001x11000xxxxxxxxxxxxxxxxxxxx
11078                                                 and.  */
11079                                              return 1298;
11080                                            }
11081                                        }
11082                                      else
11083                                        {
11084                                          if (((word >> 23) & 0x1) == 0)
11085                                            {
11086                                              /* 33222222222211111111110000000000
11087                                                 10987654321098765432109876543210
11088                                                 000001x10100xxxxxxxxxxxxxxxxxxxx
11089                                                 eor.  */
11090                                              return 1385;
11091                                            }
11092                                          else
11093                                            {
11094                                              /* 33222222222211111111110000000000
11095                                                 10987654321098765432109876543210
11096                                                 000001x11100xxxxxxxxxxxxxxxxxxxx
11097                                                 dupm.  */
11098                                              return 1383;
11099                                            }
11100                                        }
11101                                    }
11102                                  else
11103                                    {
11104                                      if (((word >> 15) & 0x1) == 0)
11105                                        {
11106                                          /* 33222222222211111111110000000000
11107                                             10987654321098765432109876543210
11108                                             000001x1xx01xxxx0xxxxxxxxxxxxxxx
11109                                             cpy.  */
11110                                          return 1368;
11111                                        }
11112                                      else
11113                                        {
11114                                          /* 33222222222211111111110000000000
11115                                             10987654321098765432109876543210
11116                                             000001x1xx01xxxx1xxxxxxxxxxxxxxx
11117                                             fcpy.  */
11118                                          return 1415;
11119                                        }
11120                                    }
11121                                }
11122                              else
11123                                {
11124                                  if (((word >> 14) & 0x1) == 0)
11125                                    {
11126                                      if (((word >> 13) & 0x1) == 0)
11127                                        {
11128                                          if (((word >> 15) & 0x1) == 0)
11129                                            {
11130                                              if (((word >> 22) & 0x1) == 0)
11131                                                {
11132                                                  if (((word >> 23) & 0x1) == 0)
11133                                                    {
11134                                                      /* 33222222222211111111110000000000
11135                                                         10987654321098765432109876543210
11136                                                         000001x1001xxxxx000xxxxxxxxxxxxx
11137                                                         ext.  */
11138                                                      return 1390;
11139                                                    }
11140                                                  else
11141                                                    {
11142                                                      if (((word >> 10) & 0x1) == 0)
11143                                                        {
11144                                                          if (((word >> 11) & 0x1) == 0)
11145                                                            {
11146                                                              /* 33222222222211111111110000000000
11147                                                                 10987654321098765432109876543210
11148                                                                 000001x1101xxxxx000x00xxxxxxxxxx
11149                                                                 zip1.  */
11150                                                              return 2483;
11151                                                            }
11152                                                          else
11153                                                            {
11154                                                              if (((word >> 12) & 0x1) == 0)
11155                                                                {
11156                                                                  /* 33222222222211111111110000000000
11157                                                                     10987654321098765432109876543210
11158                                                                     000001x1101xxxxx000010xxxxxxxxxx
11159                                                                     uzp1.  */
11160                                                                  return 2485;
11161                                                                }
11162                                                              else
11163                                                                {
11164                                                                  /* 33222222222211111111110000000000
11165                                                                     10987654321098765432109876543210
11166                                                                     000001x1101xxxxx000110xxxxxxxxxx
11167                                                                     trn1.  */
11168                                                                  return 2487;
11169                                                                }
11170                                                            }
11171                                                        }
11172                                                      else
11173                                                        {
11174                                                          if (((word >> 11) & 0x1) == 0)
11175                                                            {
11176                                                              /* 33222222222211111111110000000000
11177                                                                 10987654321098765432109876543210
11178                                                                 000001x1101xxxxx000x01xxxxxxxxxx
11179                                                                 zip2.  */
11180                                                              return 2484;
11181                                                            }
11182                                                          else
11183                                                            {
11184                                                              if (((word >> 12) & 0x1) == 0)
11185                                                                {
11186                                                                  /* 33222222222211111111110000000000
11187                                                                     10987654321098765432109876543210
11188                                                                     000001x1101xxxxx000011xxxxxxxxxx
11189                                                                     uzp2.  */
11190                                                                  return 2486;
11191                                                                }
11192                                                              else
11193                                                                {
11194                                                                  /* 33222222222211111111110000000000
11195                                                                     10987654321098765432109876543210
11196                                                                     000001x1101xxxxx000111xxxxxxxxxx
11197                                                                     trn2.  */
11198                                                                  return 2488;
11199                                                                }
11200                                                            }
11201                                                        }
11202                                                    }
11203                                                }
11204                                              else
11205                                                {
11206                                                  /* 33222222222211111111110000000000
11207                                                     10987654321098765432109876543210
11208                                                     000001x1x11xxxxx000xxxxxxxxxxxxx
11209                                                     ext.  */
11210                                                  return 2080;
11211                                                }
11212                                            }
11213                                          else
11214                                            {
11215                                              if (((word >> 16) & 0x1) == 0)
11216                                                {
11217                                                  if (((word >> 17) & 0x1) == 0)
11218                                                    {
11219                                                      if (((word >> 18) & 0x1) == 0)
11220                                                        {
11221                                                          if (((word >> 19) & 0x1) == 0)
11222                                                            {
11223                                                              /* 33222222222211111111110000000000
11224                                                                 10987654321098765432109876543210
11225                                                                 000001x1xx1x0000100xxxxxxxxxxxxx
11226                                                                 cpy.  */
11227                                                              return 1366;
11228                                                            }
11229                                                          else
11230                                                            {
11231                                                              /* 33222222222211111111110000000000
11232                                                                 10987654321098765432109876543210
11233                                                                 000001x1xx1x1000100xxxxxxxxxxxxx
11234                                                                 clasta.  */
11235                                                              return 1324;
11236                                                            }
11237                                                        }
11238                                                      else
11239                                                        {
11240                                                          if (((word >> 19) & 0x1) == 0)
11241                                                            {
11242                                                              /* 33222222222211111111110000000000
11243                                                                 10987654321098765432109876543210
11244                                                                 000001x1xx1x0100100xxxxxxxxxxxxx
11245                                                                 revb.  */
11246                                                              return 1818;
11247                                                            }
11248                                                          else
11249                                                            {
11250                                                              /* 33222222222211111111110000000000
11251                                                                 10987654321098765432109876543210
11252                                                                 000001x1xx1x1100100xxxxxxxxxxxxx
11253                                                                 splice.  */
11254                                                              return 1845;
11255                                                            }
11256                                                        }
11257                                                    }
11258                                                  else
11259                                                    {
11260                                                      if (((word >> 18) & 0x1) == 0)
11261                                                        {
11262                                                          if (((word >> 19) & 0x1) == 0)
11263                                                            {
11264                                                              /* 33222222222211111111110000000000
11265                                                                 10987654321098765432109876543210
11266                                                                 000001x1xx1x0010100xxxxxxxxxxxxx
11267                                                                 lasta.  */
11268                                                              return 1512;
11269                                                            }
11270                                                          else
11271                                                            {
11272                                                              /* 33222222222211111111110000000000
11273                                                                 10987654321098765432109876543210
11274                                                                 000001x1xx1x1010100xxxxxxxxxxxxx
11275                                                                 clasta.  */
11276                                                              return 1325;
11277                                                            }
11278                                                        }
11279                                                      else
11280                                                        {
11281                                                          if (((word >> 19) & 0x1) == 0)
11282                                                            {
11283                                                              /* 33222222222211111111110000000000
11284                                                                 10987654321098765432109876543210
11285                                                                 000001x1xx1x0110100xxxxxxxxxxxxx
11286                                                                 revw.  */
11287                                                              return 1820;
11288                                                            }
11289                                                          else
11290                                                            {
11291                                                              /* 33222222222211111111110000000000
11292                                                                 10987654321098765432109876543210
11293                                                                 000001x1xx1x1110100xxxxxxxxxxxxx
11294                                                                 revd.  */
11295                                                              return 2410;
11296                                                            }
11297                                                        }
11298                                                    }
11299                                                }
11300                                              else
11301                                                {
11302                                                  if (((word >> 17) & 0x1) == 0)
11303                                                    {
11304                                                      if (((word >> 18) & 0x1) == 0)
11305                                                        {
11306                                                          if (((word >> 19) & 0x1) == 0)
11307                                                            {
11308                                                              /* 33222222222211111111110000000000
11309                                                                 10987654321098765432109876543210
11310                                                                 000001x1xx1x0001100xxxxxxxxxxxxx
11311                                                                 compact.  */
11312                                                              return 1365;
11313                                                            }
11314                                                          else
11315                                                            {
11316                                                              /* 33222222222211111111110000000000
11317                                                                 10987654321098765432109876543210
11318                                                                 000001x1xx1x1001100xxxxxxxxxxxxx
11319                                                                 clastb.  */
11320                                                              return 1327;
11321                                                            }
11322                                                        }
11323                                                      else
11324                                                        {
11325                                                          if (((word >> 19) & 0x1) == 0)
11326                                                            {
11327                                                              /* 33222222222211111111110000000000
11328                                                                 10987654321098765432109876543210
11329                                                                 000001x1xx1x0101100xxxxxxxxxxxxx
11330                                                                 revh.  */
11331                                                              return 1819;
11332                                                            }
11333                                                          else
11334                                                            {
11335                                                              /* 33222222222211111111110000000000
11336                                                                 10987654321098765432109876543210
11337                                                                 000001x1xx1x1101100xxxxxxxxxxxxx
11338                                                                 splice.  */
11339                                                              return 2175;
11340                                                            }
11341                                                        }
11342                                                    }
11343                                                  else
11344                                                    {
11345                                                      if (((word >> 18) & 0x1) == 0)
11346                                                        {
11347                                                          if (((word >> 19) & 0x1) == 0)
11348                                                            {
11349                                                              /* 33222222222211111111110000000000
11350                                                                 10987654321098765432109876543210
11351                                                                 000001x1xx1x0011100xxxxxxxxxxxxx
11352                                                                 lastb.  */
11353                                                              return 1514;
11354                                                            }
11355                                                          else
11356                                                            {
11357                                                              /* 33222222222211111111110000000000
11358                                                                 10987654321098765432109876543210
11359                                                                 000001x1xx1x1011100xxxxxxxxxxxxx
11360                                                                 clastb.  */
11361                                                              return 1328;
11362                                                            }
11363                                                        }
11364                                                      else
11365                                                        {
11366                                                          /* 33222222222211111111110000000000
11367                                                             10987654321098765432109876543210
11368                                                             000001x1xx1xx111100xxxxxxxxxxxxx
11369                                                             rbit.  */
11370                                                          return 1811;
11371                                                        }
11372                                                    }
11373                                                }
11374                                            }
11375                                        }
11376                                      else
11377                                        {
11378                                          if (((word >> 15) & 0x1) == 0)
11379                                            {
11380                                              if (((word >> 10) & 0x1) == 0)
11381                                                {
11382                                                  if (((word >> 11) & 0x1) == 0)
11383                                                    {
11384                                                      if (((word >> 12) & 0x1) == 0)
11385                                                        {
11386                                                          /* 33222222222211111111110000000000
11387                                                             10987654321098765432109876543210
11388                                                             000001x1xx1xxxxx001000xxxxxxxxxx
11389                                                             dup.  */
11390                                                          return 1381;
11391                                                        }
11392                                                      else
11393                                                        {
11394                                                          /* 33222222222211111111110000000000
11395                                                             10987654321098765432109876543210
11396                                                             000001x1xx1xxxxx001100xxxxxxxxxx
11397                                                             tbl.  */
11398                                                          return 1968;
11399                                                        }
11400                                                    }
11401                                                  else
11402                                                    {
11403                                                      if (((word >> 12) & 0x1) == 0)
11404                                                        {
11405                                                          /* 33222222222211111111110000000000
11406                                                             10987654321098765432109876543210
11407                                                             000001x1xx1xxxxx001010xxxxxxxxxx
11408                                                             tbl.  */
11409                                                          return 2264;
11410                                                        }
11411                                                      else
11412                                                        {
11413                                                          if (((word >> 16) & 0x1) == 0)
11414                                                            {
11415                                                              if (((word >> 17) & 0x1) == 0)
11416                                                                {
11417                                                                  if (((word >> 18) & 0x1) == 0)
11418                                                                    {
11419                                                                      if (((word >> 19) & 0x1) == 0)
11420                                                                        {
11421                                                                          if (((word >> 20) & 0x1) == 0)
11422                                                                            {
11423                                                                              /* 33222222222211111111110000000000
11424                                                                                 10987654321098765432109876543210
11425                                                                                 000001x1xx100000001110xxxxxxxxxx
11426                                                                                 dup.  */
11427                                                                              return 1380;
11428                                                                            }
11429                                                                          else
11430                                                                            {
11431                                                                              /* 33222222222211111111110000000000
11432                                                                                 10987654321098765432109876543210
11433                                                                                 000001x1xx110000001110xxxxxxxxxx
11434                                                                                 sunpklo.  */
11435                                                                              return 1964;
11436                                                                            }
11437                                                                        }
11438                                                                      else
11439                                                                        {
11440                                                                          /* 33222222222211111111110000000000
11441                                                                             10987654321098765432109876543210
11442                                                                             000001x1xx1x1000001110xxxxxxxxxx
11443                                                                             rev.  */
11444                                                                          return 1817;
11445                                                                        }
11446                                                                    }
11447                                                                  else
11448                                                                    {
11449                                                                      if (((word >> 20) & 0x1) == 0)
11450                                                                        {
11451                                                                          /* 33222222222211111111110000000000
11452                                                                             10987654321098765432109876543210
11453                                                                             000001x1xx10x100001110xxxxxxxxxx
11454                                                                             insr.  */
11455                                                                          return 1509;
11456                                                                        }
11457                                                                      else
11458                                                                        {
11459                                                                          /* 33222222222211111111110000000000
11460                                                                             10987654321098765432109876543210
11461                                                                             000001x1xx11x100001110xxxxxxxxxx
11462                                                                             insr.  */
11463                                                                          return 1510;
11464                                                                        }
11465                                                                    }
11466                                                                }
11467                                                              else
11468                                                                {
11469                                                                  /* 33222222222211111111110000000000
11470                                                                     10987654321098765432109876543210
11471                                                                     000001x1xx1xxx10001110xxxxxxxxxx
11472                                                                     uunpklo.  */
11473                                                                  return 2027;
11474                                                                }
11475                                                            }
11476                                                          else
11477                                                            {
11478                                                              if (((word >> 17) & 0x1) == 0)
11479                                                                {
11480                                                                  /* 33222222222211111111110000000000
11481                                                                     10987654321098765432109876543210
11482                                                                     000001x1xx1xxx01001110xxxxxxxxxx
11483                                                                     sunpkhi.  */
11484                                                                  return 1963;
11485                                                                }
11486                                                              else
11487                                                                {
11488                                                                  /* 33222222222211111111110000000000
11489                                                                     10987654321098765432109876543210
11490                                                                     000001x1xx1xxx11001110xxxxxxxxxx
11491                                                                     uunpkhi.  */
11492                                                                  return 2026;
11493                                                                }
11494                                                            }
11495                                                        }
11496                                                    }
11497                                                }
11498                                              else
11499                                                {
11500                                                  /* 33222222222211111111110000000000
11501                                                     10987654321098765432109876543210
11502                                                     000001x1xx1xxxxx001xx1xxxxxxxxxx
11503                                                     tbx.  */
11504                                                  return 2265;
11505                                                }
11506                                            }
11507                                          else
11508                                            {
11509                                              if (((word >> 16) & 0x1) == 0)
11510                                                {
11511                                                  if (((word >> 19) & 0x1) == 0)
11512                                                    {
11513                                                      if (((word >> 20) & 0x1) == 0)
11514                                                        {
11515                                                          /* 33222222222211111111110000000000
11516                                                             10987654321098765432109876543210
11517                                                             000001x1xx100xx0101xxxxxxxxxxxxx
11518                                                             lasta.  */
11519                                                          return 1511;
11520                                                        }
11521                                                      else
11522                                                        {
11523                                                          /* 33222222222211111111110000000000
11524                                                             10987654321098765432109876543210
11525                                                             000001x1xx110xx0101xxxxxxxxxxxxx
11526                                                             clasta.  */
11527                                                          return 1326;
11528                                                        }
11529                                                    }
11530                                                  else
11531                                                    {
11532                                                      /* 33222222222211111111110000000000
11533                                                         10987654321098765432109876543210
11534                                                         000001x1xx1x1xx0101xxxxxxxxxxxxx
11535                                                         cpy.  */
11536                                                      return 1367;
11537                                                    }
11538                                                }
11539                                              else
11540                                                {
11541                                                  if (((word >> 20) & 0x1) == 0)
11542                                                    {
11543                                                      /* 33222222222211111111110000000000
11544                                                         10987654321098765432109876543210
11545                                                         000001x1xx10xxx1101xxxxxxxxxxxxx
11546                                                         lastb.  */
11547                                                      return 1513;
11548                                                    }
11549                                                  else
11550                                                    {
11551                                                      /* 33222222222211111111110000000000
11552                                                         10987654321098765432109876543210
11553                                                         000001x1xx11xxx1101xxxxxxxxxxxxx
11554                                                         clastb.  */
11555                                                      return 1329;
11556                                                    }
11557                                                }
11558                                            }
11559                                        }
11560                                    }
11561                                  else
11562                                    {
11563                                      if (((word >> 15) & 0x1) == 0)
11564                                        {
11565                                          if (((word >> 10) & 0x1) == 0)
11566                                            {
11567                                              if (((word >> 11) & 0x1) == 0)
11568                                                {
11569                                                  if (((word >> 12) & 0x1) == 0)
11570                                                    {
11571                                                      if (((word >> 13) & 0x1) == 0)
11572                                                        {
11573                                                          if (((word >> 20) & 0x1) == 0)
11574                                                            {
11575                                                              /* 33222222222211111111110000000000
11576                                                                 10987654321098765432109876543210
11577                                                                 000001x1xx10xxxx010000xxxxxxxxxx
11578                                                                 zip1.  */
11579                                                              return 2044;
11580                                                            }
11581                                                          else
11582                                                            {
11583                                                              if (((word >> 16) & 0x1) == 0)
11584                                                                {
11585                                                                  if (((word >> 18) & 0x1) == 0)
11586                                                                    {
11587                                                                      /* 33222222222211111111110000000000
11588                                                                         10987654321098765432109876543210
11589                                                                         000001x1xx11x0x0010000xxxxxxxxxx
11590                                                                         punpklo.  */
11591                                                                      return 1810;
11592                                                                    }
11593                                                                  else
11594                                                                    {
11595                                                                      /* 33222222222211111111110000000000
11596                                                                         10987654321098765432109876543210
11597                                                                         000001x1xx11x1x0010000xxxxxxxxxx
11598                                                                         rev.  */
11599                                                                      return 1816;
11600                                                                    }
11601                                                                }
11602                                                              else
11603                                                                {
11604                                                                  /* 33222222222211111111110000000000
11605                                                                     10987654321098765432109876543210
11606                                                                     000001x1xx11xxx1010000xxxxxxxxxx
11607                                                                     punpkhi.  */
11608                                                                  return 1809;
11609                                                                }
11610                                                            }
11611                                                        }
11612                                                      else
11613                                                        {
11614                                                          /* 33222222222211111111110000000000
11615                                                             10987654321098765432109876543210
11616                                                             000001x1xx1xxxxx011000xxxxxxxxxx
11617                                                             zip1.  */
11618                                                          return 2045;
11619                                                        }
11620                                                    }
11621                                                  else
11622                                                    {
11623                                                      if (((word >> 13) & 0x1) == 0)
11624                                                        {
11625                                                          /* 33222222222211111111110000000000
11626                                                             10987654321098765432109876543210
11627                                                             000001x1xx1xxxxx010100xxxxxxxxxx
11628                                                             trn1.  */
11629                                                          return 1969;
11630                                                        }
11631                                                      else
11632                                                        {
11633                                                          /* 33222222222211111111110000000000
11634                                                             10987654321098765432109876543210
11635                                                             000001x1xx1xxxxx011100xxxxxxxxxx
11636                                                             trn1.  */
11637                                                          return 1970;
11638                                                        }
11639                                                    }
11640                                                }
11641                                              else
11642                                                {
11643                                                  if (((word >> 13) & 0x1) == 0)
11644                                                    {
11645                                                      /* 33222222222211111111110000000000
11646                                                         10987654321098765432109876543210
11647                                                         000001x1xx1xxxxx010x10xxxxxxxxxx
11648                                                         uzp1.  */
11649                                                      return 2031;
11650                                                    }
11651                                                  else
11652                                                    {
11653                                                      /* 33222222222211111111110000000000
11654                                                         10987654321098765432109876543210
11655                                                         000001x1xx1xxxxx011x10xxxxxxxxxx
11656                                                         uzp1.  */
11657                                                      return 2032;
11658                                                    }
11659                                                }
11660                                            }
11661                                          else
11662                                            {
11663                                              if (((word >> 11) & 0x1) == 0)
11664                                                {
11665                                                  if (((word >> 12) & 0x1) == 0)
11666                                                    {
11667                                                      if (((word >> 13) & 0x1) == 0)
11668                                                        {
11669                                                          /* 33222222222211111111110000000000
11670                                                             10987654321098765432109876543210
11671                                                             000001x1xx1xxxxx010001xxxxxxxxxx
11672                                                             zip2.  */
11673                                                          return 2046;
11674                                                        }
11675                                                      else
11676                                                        {
11677                                                          /* 33222222222211111111110000000000
11678                                                             10987654321098765432109876543210
11679                                                             000001x1xx1xxxxx011001xxxxxxxxxx
11680                                                             zip2.  */
11681                                                          return 2047;
11682                                                        }
11683                                                    }
11684                                                  else
11685                                                    {
11686                                                      if (((word >> 13) & 0x1) == 0)
11687                                                        {
11688                                                          /* 33222222222211111111110000000000
11689                                                             10987654321098765432109876543210
11690                                                             000001x1xx1xxxxx010101xxxxxxxxxx
11691                                                             trn2.  */
11692                                                          return 1971;
11693                                                        }
11694                                                      else
11695                                                        {
11696                                                          /* 33222222222211111111110000000000
11697                                                             10987654321098765432109876543210
11698                                                             000001x1xx1xxxxx011101xxxxxxxxxx
11699                                                             trn2.  */
11700                                                          return 1972;
11701                                                        }
11702                                                    }
11703                                                }
11704                                              else
11705                                                {
11706                                                  if (((word >> 13) & 0x1) == 0)
11707                                                    {
11708                                                      /* 33222222222211111111110000000000
11709                                                         10987654321098765432109876543210
11710                                                         000001x1xx1xxxxx010x11xxxxxxxxxx
11711                                                         uzp2.  */
11712                                                      return 2033;
11713                                                    }
11714                                                  else
11715                                                    {
11716                                                      /* 33222222222211111111110000000000
11717                                                         10987654321098765432109876543210
11718                                                         000001x1xx1xxxxx011x11xxxxxxxxxx
11719                                                         uzp2.  */
11720                                                      return 2034;
11721                                                    }
11722                                                }
11723                                            }
11724                                        }
11725                                      else
11726                                        {
11727                                          /* 33222222222211111111110000000000
11728                                             10987654321098765432109876543210
11729                                             000001x1xx1xxxxx11xxxxxxxxxxxxxx
11730                                             sel.  */
11731                                          return 1835;
11732                                        }
11733                                    }
11734                                }
11735                            }
11736                          else
11737                            {
11738                              if (((word >> 13) & 0x1) == 0)
11739                                {
11740                                  if (((word >> 14) & 0x1) == 0)
11741                                    {
11742                                      if (((word >> 15) & 0x1) == 0)
11743                                        {
11744                                          if (((word >> 22) & 0x1) == 0)
11745                                            {
11746                                              /* 33222222222211111111110000000000
11747                                                 10987654321098765432109876543210
11748                                                 100001x1x0xxxxxx000xxxxxxxxxxxxx
11749                                                 ldr.  */
11750                                              return 1739;
11751                                            }
11752                                          else
11753                                            {
11754                                              /* 33222222222211111111110000000000
11755                                                 10987654321098765432109876543210
11756                                                 100001x1x1xxxxxx000xxxxxxxxxxxxx
11757                                                 prfb.  */
11758                                              return 1783;
11759                                            }
11760                                        }
11761                                      else
11762                                        {
11763                                          if (((word >> 23) & 0x1) == 0)
11764                                            {
11765                                              /* 33222222222211111111110000000000
11766                                                 10987654321098765432109876543210
11767                                                 100001x10xxxxxxx100xxxxxxxxxxxxx
11768                                                 ld1rsh.  */
11769                                              return 1568;
11770                                            }
11771                                          else
11772                                            {
11773                                              /* 33222222222211111111110000000000
11774                                                 10987654321098765432109876543210
11775                                                 100001x11xxxxxxx100xxxxxxxxxxxxx
11776                                                 ld1rsb.  */
11777                                              return 1565;
11778                                            }
11779                                        }
11780                                    }
11781                                  else
11782                                    {
11783                                      if (((word >> 15) & 0x1) == 0)
11784                                        {
11785                                          if (((word >> 23) & 0x1) == 0)
11786                                            {
11787                                              if (((word >> 21) & 0x1) == 0)
11788                                                {
11789                                                  /* 33222222222211111111110000000000
11790                                                     10987654321098765432109876543210
11791                                                     100001x10x0xxxxx010xxxxxxxxxxxxx
11792                                                     ld1w.  */
11793                                                  return 1603;
11794                                                }
11795                                              else
11796                                                {
11797                                                  /* 33222222222211111111110000000000
11798                                                     10987654321098765432109876543210
11799                                                     100001x10x1xxxxx010xxxxxxxxxxxxx
11800                                                     ld1w.  */
11801                                                  return 1604;
11802                                                }
11803                                            }
11804                                          else
11805                                            {
11806                                              if (((word >> 22) & 0x1) == 0)
11807                                                {
11808                                                  /* 33222222222211111111110000000000
11809                                                     10987654321098765432109876543210
11810                                                     100001x110xxxxxx010xxxxxxxxxxxxx
11811                                                     ldr.  */
11812                                                  return 1740;
11813                                                }
11814                                              else
11815                                                {
11816                                                  /* 33222222222211111111110000000000
11817                                                     10987654321098765432109876543210
11818                                                     100001x111xxxxxx010xxxxxxxxxxxxx
11819                                                     prfw.  */
11820                                                  return 1804;
11821                                                }
11822                                            }
11823                                        }
11824                                      else
11825                                        {
11826                                          if (((word >> 22) & 0x1) == 0)
11827                                            {
11828                                              if (((word >> 21) & 0x1) == 0)
11829                                                {
11830                                                  if (((word >> 23) & 0x1) == 0)
11831                                                    {
11832                                                      /* 33222222222211111111110000000000
11833                                                         10987654321098765432109876543210
11834                                                         100001x1000xxxxx110xxxxxxxxxxxxx
11835                                                         prfw.  */
11836                                                      return 1800;
11837                                                    }
11838                                                  else
11839                                                    {
11840                                                      /* 33222222222211111111110000000000
11841                                                         10987654321098765432109876543210
11842                                                         100001x1100xxxxx110xxxxxxxxxxxxx
11843                                                         prfd.  */
11844                                                      return 1786;
11845                                                    }
11846                                                }
11847                                              else
11848                                                {
11849                                                  /* 33222222222211111111110000000000
11850                                                     10987654321098765432109876543210
11851                                                     100001x1x01xxxxx110xxxxxxxxxxxxx
11852                                                     ld1w.  */
11853                                                  return 1611;
11854                                                }
11855                                            }
11856                                          else
11857                                            {
11858                                              if (((word >> 23) & 0x1) == 0)
11859                                                {
11860                                                  /* 33222222222211111111110000000000
11861                                                     10987654321098765432109876543210
11862                                                     100001x101xxxxxx110xxxxxxxxxxxxx
11863                                                     ld1rw.  */
11864                                                  return 1571;
11865                                                }
11866                                              else
11867                                                {
11868                                                  /* 33222222222211111111110000000000
11869                                                     10987654321098765432109876543210
11870                                                     100001x111xxxxxx110xxxxxxxxxxxxx
11871                                                     ld1rsb.  */
11872                                                  return 1567;
11873                                                }
11874                                            }
11875                                        }
11876                                    }
11877                                }
11878                              else
11879                                {
11880                                  if (((word >> 14) & 0x1) == 0)
11881                                    {
11882                                      if (((word >> 15) & 0x1) == 0)
11883                                        {
11884                                          /* 33222222222211111111110000000000
11885                                             10987654321098765432109876543210
11886                                             100001x1xxxxxxxx001xxxxxxxxxxxxx
11887                                             prfh.  */
11888                                          return 1797;
11889                                        }
11890                                      else
11891                                        {
11892                                          if (((word >> 22) & 0x1) == 0)
11893                                            {
11894                                              /* 33222222222211111111110000000000
11895                                                 10987654321098765432109876543210
11896                                                 100001x1x0xxxxxx101xxxxxxxxxxxxx
11897                                                 ldnt1w.  */
11898                                              return 2111;
11899                                            }
11900                                          else
11901                                            {
11902                                              if (((word >> 23) & 0x1) == 0)
11903                                                {
11904                                                  /* 33222222222211111111110000000000
11905                                                     10987654321098765432109876543210
11906                                                     100001x101xxxxxx101xxxxxxxxxxxxx
11907                                                     ld1rsh.  */
11908                                                  return 1569;
11909                                                }
11910                                              else
11911                                                {
11912                                                  /* 33222222222211111111110000000000
11913                                                     10987654321098765432109876543210
11914                                                     100001x111xxxxxx101xxxxxxxxxxxxx
11915                                                     ld1rsb.  */
11916                                                  return 1566;
11917                                                }
11918                                            }
11919                                        }
11920                                    }
11921                                  else
11922                                    {
11923                                      if (((word >> 15) & 0x1) == 0)
11924                                        {
11925                                          if (((word >> 23) & 0x1) == 0)
11926                                            {
11927                                              if (((word >> 21) & 0x1) == 0)
11928                                                {
11929                                                  /* 33222222222211111111110000000000
11930                                                     10987654321098765432109876543210
11931                                                     100001x10x0xxxxx011xxxxxxxxxxxxx
11932                                                     ldff1w.  */
11933                                                  return 1703;
11934                                                }
11935                                              else
11936                                                {
11937                                                  /* 33222222222211111111110000000000
11938                                                     10987654321098765432109876543210
11939                                                     100001x10x1xxxxx011xxxxxxxxxxxxx
11940                                                     ldff1w.  */
11941                                                  return 1704;
11942                                                }
11943                                            }
11944                                          else
11945                                            {
11946                                              /* 33222222222211111111110000000000
11947                                                 10987654321098765432109876543210
11948                                                 100001x11xxxxxxx011xxxxxxxxxxxxx
11949                                                 prfd.  */
11950                                              return 1790;
11951                                            }
11952                                        }
11953                                      else
11954                                        {
11955                                          if (((word >> 22) & 0x1) == 0)
11956                                            {
11957                                              if (((word >> 21) & 0x1) == 0)
11958                                                {
11959                                                  if (((word >> 23) & 0x1) == 0)
11960                                                    {
11961                                                      /* 33222222222211111111110000000000
11962                                                         10987654321098765432109876543210
11963                                                         100001x1000xxxxx111xxxxxxxxxxxxx
11964                                                         prfw.  */
11965                                                      return 1803;
11966                                                    }
11967                                                  else
11968                                                    {
11969                                                      /* 33222222222211111111110000000000
11970                                                         10987654321098765432109876543210
11971                                                         100001x1100xxxxx111xxxxxxxxxxxxx
11972                                                         prfd.  */
11973                                                      return 1789;
11974                                                    }
11975                                                }
11976                                              else
11977                                                {
11978                                                  /* 33222222222211111111110000000000
11979                                                     10987654321098765432109876543210
11980                                                     100001x1x01xxxxx111xxxxxxxxxxxxx
11981                                                     ldff1w.  */
11982                                                  return 1713;
11983                                                }
11984                                            }
11985                                          else
11986                                            {
11987                                              if (((word >> 23) & 0x1) == 0)
11988                                                {
11989                                                  /* 33222222222211111111110000000000
11990                                                     10987654321098765432109876543210
11991                                                     100001x101xxxxxx111xxxxxxxxxxxxx
11992                                                     ld1rw.  */
11993                                                  return 1572;
11994                                                }
11995                                              else
11996                                                {
11997                                                  /* 33222222222211111111110000000000
11998                                                     10987654321098765432109876543210
11999                                                     100001x111xxxxxx111xxxxxxxxxxxxx
12000                                                     ld1rd.  */
12001                                                  return 1553;
12002                                                }
12003                                            }
12004                                        }
12005                                    }
12006                                }
12007                            }
12008                        }
12009                      else
12010                        {
12011                          if (((word >> 13) & 0x1) == 0)
12012                            {
12013                              if (((word >> 14) & 0x1) == 0)
12014                                {
12015                                  if (((word >> 15) & 0x1) == 0)
12016                                    {
12017                                      if (((word >> 21) & 0x1) == 0)
12018                                        {
12019                                          if (((word >> 31) & 0x1) == 0)
12020                                            {
12021                                              if (((word >> 10) & 0x1) == 0)
12022                                                {
12023                                                  if (((word >> 11) & 0x1) == 0)
12024                                                    {
12025                                                      if (((word >> 12) & 0x1) == 0)
12026                                                        {
12027                                                          /* 33222222222211111111110000000000
12028                                                             10987654321098765432109876543210
12029                                                             010001x1xx0xxxxx000000xxxxxxxxxx
12030                                                             saddlb.  */
12031                                                          return 2141;
12032                                                        }
12033                                                      else
12034                                                        {
12035                                                          /* 33222222222211111111110000000000
12036                                                             10987654321098765432109876543210
12037                                                             010001x1xx0xxxxx000100xxxxxxxxxx
12038                                                             ssublb.  */
12039                                                          return 2248;
12040                                                        }
12041                                                    }
12042                                                  else
12043                                                    {
12044                                                      if (((word >> 12) & 0x1) == 0)
12045                                                        {
12046                                                          /* 33222222222211111111110000000000
12047                                                             10987654321098765432109876543210
12048                                                             010001x1xx0xxxxx000010xxxxxxxxxx
12049                                                             uaddlb.  */
12050                                                          return 2272;
12051                                                        }
12052                                                      else
12053                                                        {
12054                                                          /* 33222222222211111111110000000000
12055                                                             10987654321098765432109876543210
12056                                                             010001x1xx0xxxxx000110xxxxxxxxxx
12057                                                             usublb.  */
12058                                                          return 2325;
12059                                                        }
12060                                                    }
12061                                                }
12062                                              else
12063                                                {
12064                                                  if (((word >> 11) & 0x1) == 0)
12065                                                    {
12066                                                      if (((word >> 12) & 0x1) == 0)
12067                                                        {
12068                                                          /* 33222222222211111111110000000000
12069                                                             10987654321098765432109876543210
12070                                                             010001x1xx0xxxxx000001xxxxxxxxxx
12071                                                             saddlt.  */
12072                                                          return 2143;
12073                                                        }
12074                                                      else
12075                                                        {
12076                                                          /* 33222222222211111111110000000000
12077                                                             10987654321098765432109876543210
12078                                                             010001x1xx0xxxxx000101xxxxxxxxxx
12079                                                             ssublt.  */
12080                                                          return 2250;
12081                                                        }
12082                                                    }
12083                                                  else
12084                                                    {
12085                                                      if (((word >> 12) & 0x1) == 0)
12086                                                        {
12087                                                          /* 33222222222211111111110000000000
12088                                                             10987654321098765432109876543210
12089                                                             010001x1xx0xxxxx000011xxxxxxxxxx
12090                                                             uaddlt.  */
12091                                                          return 2273;
12092                                                        }
12093                                                      else
12094                                                        {
12095                                                          /* 33222222222211111111110000000000
12096                                                             10987654321098765432109876543210
12097                                                             010001x1xx0xxxxx000111xxxxxxxxxx
12098                                                             usublt.  */
12099                                                          return 2326;
12100                                                        }
12101                                                    }
12102                                                }
12103                                            }
12104                                          else
12105                                            {
12106                                              /* 33222222222211111111110000000000
12107                                                 10987654321098765432109876543210
12108                                                 110001x1xx0xxxxx000xxxxxxxxxxxxx
12109                                                 ld1sw.  */
12110                                              return 1597;
12111                                            }
12112                                        }
12113                                      else
12114                                        {
12115                                          if (((word >> 31) & 0x1) == 0)
12116                                            {
12117                                              if (((word >> 10) & 0x1) == 0)
12118                                                {
12119                                                  if (((word >> 11) & 0x1) == 0)
12120                                                    {
12121                                                      if (((word >> 12) & 0x1) == 0)
12122                                                        {
12123                                                          /* 33222222222211111111110000000000
12124                                                             10987654321098765432109876543210
12125                                                             010001x1xx1xxxxx000000xxxxxxxxxx
12126                                                             sqshrunb.  */
12127                                                          return 2231;
12128                                                        }
12129                                                      else
12130                                                        {
12131                                                          /* 33222222222211111111110000000000
12132                                                             10987654321098765432109876543210
12133                                                             010001x1xx1xxxxx000100xxxxxxxxxx
12134                                                             shrnb.  */
12135                                                          return 2149;
12136                                                        }
12137                                                    }
12138                                                  else
12139                                                    {
12140                                                      if (((word >> 12) & 0x1) == 0)
12141                                                        {
12142                                                          /* 33222222222211111111110000000000
12143                                                             10987654321098765432109876543210
12144                                                             010001x1xx1xxxxx000010xxxxxxxxxx
12145                                                             sqrshrunb.  */
12146                                                          return 2223;
12147                                                        }
12148                                                      else
12149                                                        {
12150                                                          /* 33222222222211111111110000000000
12151                                                             10987654321098765432109876543210
12152                                                             010001x1xx1xxxxx000110xxxxxxxxxx
12153                                                             rshrnb.  */
12154                                                          return 2131;
12155                                                        }
12156                                                    }
12157                                                }
12158                                              else
12159                                                {
12160                                                  if (((word >> 11) & 0x1) == 0)
12161                                                    {
12162                                                      if (((word >> 12) & 0x1) == 0)
12163                                                        {
12164                                                          /* 33222222222211111111110000000000
12165                                                             10987654321098765432109876543210
12166                                                             010001x1xx1xxxxx000001xxxxxxxxxx
12167                                                             sqshrunt.  */
12168                                                          return 2232;
12169                                                        }
12170                                                      else
12171                                                        {
12172                                                          /* 33222222222211111111110000000000
12173                                                             10987654321098765432109876543210
12174                                                             010001x1xx1xxxxx000101xxxxxxxxxx
12175                                                             shrnt.  */
12176                                                          return 2150;
12177                                                        }
12178                                                    }
12179                                                  else
12180                                                    {
12181                                                      if (((word >> 12) & 0x1) == 0)
12182                                                        {
12183                                                          /* 33222222222211111111110000000000
12184                                                             10987654321098765432109876543210
12185                                                             010001x1xx1xxxxx000011xxxxxxxxxx
12186                                                             sqrshrunt.  */
12187                                                          return 2224;
12188                                                        }
12189                                                      else
12190                                                        {
12191                                                          /* 33222222222211111111110000000000
12192                                                             10987654321098765432109876543210
12193                                                             010001x1xx1xxxxx000111xxxxxxxxxx
12194                                                             rshrnt.  */
12195                                                          return 2132;
12196                                                        }
12197                                                    }
12198                                                }
12199                                            }
12200                                          else
12201                                            {
12202                                              /* 33222222222211111111110000000000
12203                                                 10987654321098765432109876543210
12204                                                 110001x1xx1xxxxx000xxxxxxxxxxxxx
12205                                                 ld1sw.  */
12206                                              return 1598;
12207                                            }
12208                                        }
12209                                    }
12210                                  else
12211                                    {
12212                                      if (((word >> 21) & 0x1) == 0)
12213                                        {
12214                                          if (((word >> 31) & 0x1) == 0)
12215                                            {
12216                                              if (((word >> 10) & 0x1) == 0)
12217                                                {
12218                                                  if (((word >> 11) & 0x1) == 0)
12219                                                    {
12220                                                      if (((word >> 12) & 0x1) == 0)
12221                                                        {
12222                                                          /* 33222222222211111111110000000000
12223                                                             10987654321098765432109876543210
12224                                                             010001x1xx0xxxxx100000xxxxxxxxxx
12225                                                             saddlbt.  */
12226                                                          return 2142;
12227                                                        }
12228                                                      else
12229                                                        {
12230                                                          /* 33222222222211111111110000000000
12231                                                             10987654321098765432109876543210
12232                                                             010001x1xx0xxxxx100100xxxxxxxxxx
12233                                                             eorbt.  */
12234                                                          return 2078;
12235                                                        }
12236                                                    }
12237                                                  else
12238                                                    {
12239                                                      if (((word >> 12) & 0x1) == 0)
12240                                                        {
12241                                                          /* 33222222222211111111110000000000
12242                                                             10987654321098765432109876543210
12243                                                             010001x1xx0xxxxx100010xxxxxxxxxx
12244                                                             ssublbt.  */
12245                                                          return 2249;
12246                                                        }
12247                                                      else
12248                                                        {
12249                                                          if (((word >> 22) & 0x1) == 0)
12250                                                            {
12251                                                              if (((word >> 23) & 0x1) == 0)
12252                                                                {
12253                                                                  /* 33222222222211111111110000000000
12254                                                                     10987654321098765432109876543210
12255                                                                     010001x1000xxxxx100110xxxxxxxxxx
12256                                                                     smmla.  */
12257                                                                  return 2467;
12258                                                                }
12259                                                              else
12260                                                                {
12261                                                                  /* 33222222222211111111110000000000
12262                                                                     10987654321098765432109876543210
12263                                                                     010001x1100xxxxx100110xxxxxxxxxx
12264                                                                     usmmla.  */
12265                                                                  return 2469;
12266                                                                }
12267                                                            }
12268                                                          else
12269                                                            {
12270                                                              /* 33222222222211111111110000000000
12271                                                                 10987654321098765432109876543210
12272                                                                 010001x1x10xxxxx100110xxxxxxxxxx
12273                                                                 ummla.  */
12274                                                              return 2468;
12275                                                            }
12276                                                        }
12277                                                    }
12278                                                }
12279                                              else
12280                                                {
12281                                                  if (((word >> 11) & 0x1) == 0)
12282                                                    {
12283                                                      /* 33222222222211111111110000000000
12284                                                         10987654321098765432109876543210
12285                                                         010001x1xx0xxxxx100x01xxxxxxxxxx
12286                                                         eortb.  */
12287                                                      return 2079;
12288                                                    }
12289                                                  else
12290                                                    {
12291                                                      /* 33222222222211111111110000000000
12292                                                         10987654321098765432109876543210
12293                                                         010001x1xx0xxxxx100x11xxxxxxxxxx
12294                                                         ssubltb.  */
12295                                                      return 2251;
12296                                                    }
12297                                                }
12298                                            }
12299                                          else
12300                                            {
12301                                              if (((word >> 22) & 0x1) == 0)
12302                                                {
12303                                                  /* 33222222222211111111110000000000
12304                                                     10987654321098765432109876543210
12305                                                     110001x1x00xxxxx100xxxxxxxxxxxxx
12306                                                     ldnt1sw.  */
12307                                                  return 2110;
12308                                                }
12309                                              else
12310                                                {
12311                                                  /* 33222222222211111111110000000000
12312                                                     10987654321098765432109876543210
12313                                                     110001x1x10xxxxx100xxxxxxxxxxxxx
12314                                                     ld1sw.  */
12315                                                  return 1599;
12316                                                }
12317                                            }
12318                                        }
12319                                      else
12320                                        {
12321                                          if (((word >> 31) & 0x1) == 0)
12322                                            {
12323                                              if (((word >> 4) & 0x1) == 0)
12324                                                {
12325                                                  /* 33222222222211111111110000000000
12326                                                     10987654321098765432109876543210
12327                                                     010001x1xx1xxxxx100xxxxxxxx0xxxx
12328                                                     match.  */
12329                                                  return 2113;
12330                                                }
12331                                              else
12332                                                {
12333                                                  /* 33222222222211111111110000000000
12334                                                     10987654321098765432109876543210
12335                                                     010001x1xx1xxxxx100xxxxxxxx1xxxx
12336                                                     nmatch.  */
12337                                                  return 2125;
12338                                                }
12339                                            }
12340                                          else
12341                                            {
12342                                              if (((word >> 22) & 0x1) == 0)
12343                                                {
12344                                                  /* 33222222222211111111110000000000
12345                                                     10987654321098765432109876543210
12346                                                     110001x1x01xxxxx100xxxxxxxxxxxxx
12347                                                     ld1sw.  */
12348                                                  return 1602;
12349                                                }
12350                                              else
12351                                                {
12352                                                  /* 33222222222211111111110000000000
12353                                                     10987654321098765432109876543210
12354                                                     110001x1x11xxxxx100xxxxxxxxxxxxx
12355                                                     ld1sw.  */
12356                                                  return 1600;
12357                                                }
12358                                            }
12359                                        }
12360                                    }
12361                                }
12362                              else
12363                                {
12364                                  if (((word >> 15) & 0x1) == 0)
12365                                    {
12366                                      if (((word >> 21) & 0x1) == 0)
12367                                        {
12368                                          if (((word >> 31) & 0x1) == 0)
12369                                            {
12370                                              if (((word >> 10) & 0x1) == 0)
12371                                                {
12372                                                  if (((word >> 11) & 0x1) == 0)
12373                                                    {
12374                                                      if (((word >> 12) & 0x1) == 0)
12375                                                        {
12376                                                          /* 33222222222211111111110000000000
12377                                                             10987654321098765432109876543210
12378                                                             010001x1xx0xxxxx010000xxxxxxxxxx
12379                                                             saddwb.  */
12380                                                          return 2144;
12381                                                        }
12382                                                      else
12383                                                        {
12384                                                          /* 33222222222211111111110000000000
12385                                                             10987654321098765432109876543210
12386                                                             010001x1xx0xxxxx010100xxxxxxxxxx
12387                                                             ssubwb.  */
12388                                                          return 2252;
12389                                                        }
12390                                                    }
12391                                                  else
12392                                                    {
12393                                                      if (((word >> 12) & 0x1) == 0)
12394                                                        {
12395                                                          /* 33222222222211111111110000000000
12396                                                             10987654321098765432109876543210
12397                                                             010001x1xx0xxxxx010010xxxxxxxxxx
12398                                                             uaddwb.  */
12399                                                          return 2274;
12400                                                        }
12401                                                      else
12402                                                        {
12403                                                          /* 33222222222211111111110000000000
12404                                                             10987654321098765432109876543210
12405                                                             010001x1xx0xxxxx010110xxxxxxxxxx
12406                                                             usubwb.  */
12407                                                          return 2327;
12408                                                        }
12409                                                    }
12410                                                }
12411                                              else
12412                                                {
12413                                                  if (((word >> 11) & 0x1) == 0)
12414                                                    {
12415                                                      if (((word >> 12) & 0x1) == 0)
12416                                                        {
12417                                                          /* 33222222222211111111110000000000
12418                                                             10987654321098765432109876543210
12419                                                             010001x1xx0xxxxx010001xxxxxxxxxx
12420                                                             saddwt.  */
12421                                                          return 2145;
12422                                                        }
12423                                                      else
12424                                                        {
12425                                                          /* 33222222222211111111110000000000
12426                                                             10987654321098765432109876543210
12427                                                             010001x1xx0xxxxx010101xxxxxxxxxx
12428                                                             ssubwt.  */
12429                                                          return 2253;
12430                                                        }
12431                                                    }
12432                                                  else
12433                                                    {
12434                                                      if (((word >> 12) & 0x1) == 0)
12435                                                        {
12436                                                          /* 33222222222211111111110000000000
12437                                                             10987654321098765432109876543210
12438                                                             010001x1xx0xxxxx010011xxxxxxxxxx
12439                                                             uaddwt.  */
12440                                                          return 2275;
12441                                                        }
12442                                                      else
12443                                                        {
12444                                                          /* 33222222222211111111110000000000
12445                                                             10987654321098765432109876543210
12446                                                             010001x1xx0xxxxx010111xxxxxxxxxx
12447                                                             usubwt.  */
12448                                                          return 2328;
12449                                                        }
12450                                                    }
12451                                                }
12452                                            }
12453                                          else
12454                                            {
12455                                              if (((word >> 23) & 0x1) == 0)
12456                                                {
12457                                                  /* 33222222222211111111110000000000
12458                                                     10987654321098765432109876543210
12459                                                     110001x10x0xxxxx010xxxxxxxxxxxxx
12460                                                     ld1w.  */
12461                                                  return 1607;
12462                                                }
12463                                              else
12464                                                {
12465                                                  /* 33222222222211111111110000000000
12466                                                     10987654321098765432109876543210
12467                                                     110001x11x0xxxxx010xxxxxxxxxxxxx
12468                                                     ld1d.  */
12469                                                  return 1529;
12470                                                }
12471                                            }
12472                                        }
12473                                      else
12474                                        {
12475                                          if (((word >> 23) & 0x1) == 0)
12476                                            {
12477                                              if (((word >> 31) & 0x1) == 0)
12478                                                {
12479                                                  if (((word >> 10) & 0x1) == 0)
12480                                                    {
12481                                                      if (((word >> 11) & 0x1) == 0)
12482                                                        {
12483                                                          if (((word >> 12) & 0x1) == 0)
12484                                                            {
12485                                                              /* 33222222222211111111110000000000
12486                                                                 10987654321098765432109876543210
12487                                                                 010001x10x1xxxxx010000xxxxxxxxxx
12488                                                                 sqxtnb.  */
12489                                                              return 2235;
12490                                                            }
12491                                                          else
12492                                                            {
12493                                                              /* 33222222222211111111110000000000
12494                                                                 10987654321098765432109876543210
12495                                                                 010001x10x1xxxxx010100xxxxxxxxxx
12496                                                                 sqxtunb.  */
12497                                                              return 2237;
12498                                                            }
12499                                                        }
12500                                                      else
12501                                                        {
12502                                                          /* 33222222222211111111110000000000
12503                                                             10987654321098765432109876543210
12504                                                             010001x10x1xxxxx010x10xxxxxxxxxx
12505                                                             uqxtnb.  */
12506                                                          return 2312;
12507                                                        }
12508                                                    }
12509                                                  else
12510                                                    {
12511                                                      if (((word >> 11) & 0x1) == 0)
12512                                                        {
12513                                                          if (((word >> 12) & 0x1) == 0)
12514                                                            {
12515                                                              /* 33222222222211111111110000000000
12516                                                                 10987654321098765432109876543210
12517                                                                 010001x10x1xxxxx010001xxxxxxxxxx
12518                                                                 sqxtnt.  */
12519                                                              return 2236;
12520                                                            }
12521                                                          else
12522                                                            {
12523                                                              /* 33222222222211111111110000000000
12524                                                                 10987654321098765432109876543210
12525                                                                 010001x10x1xxxxx010101xxxxxxxxxx
12526                                                                 sqxtunt.  */
12527                                                              return 2238;
12528                                                            }
12529                                                        }
12530                                                      else
12531                                                        {
12532                                                          /* 33222222222211111111110000000000
12533                                                             10987654321098765432109876543210
12534                                                             010001x10x1xxxxx010x11xxxxxxxxxx
12535                                                             uqxtnt.  */
12536                                                          return 2313;
12537                                                        }
12538                                                    }
12539                                                }
12540                                              else
12541                                                {
12542                                                  /* 33222222222211111111110000000000
12543                                                     10987654321098765432109876543210
12544                                                     110001x10x1xxxxx010xxxxxxxxxxxxx
12545                                                     ld1w.  */
12546                                                  return 1608;
12547                                                }
12548                                            }
12549                                          else
12550                                            {
12551                                              /* 33222222222211111111110000000000
12552                                                 10987654321098765432109876543210
12553                                                 x10001x11x1xxxxx010xxxxxxxxxxxxx
12554                                                 ld1d.  */
12555                                              return 1530;
12556                                            }
12557                                        }
12558                                    }
12559                                  else
12560                                    {
12561                                      if (((word >> 21) & 0x1) == 0)
12562                                        {
12563                                          if (((word >> 31) & 0x1) == 0)
12564                                            {
12565                                              if (((word >> 11) & 0x1) == 0)
12566                                                {
12567                                                  if (((word >> 10) & 0x1) == 0)
12568                                                    {
12569                                                      if (((word >> 12) & 0x1) == 0)
12570                                                        {
12571                                                          /* 33222222222211111111110000000000
12572                                                             10987654321098765432109876543210
12573                                                             010001x1xx0xxxxx110000xxxxxxxxxx
12574                                                             sabalb.  */
12575                                                          return 2136;
12576                                                        }
12577                                                      else
12578                                                        {
12579                                                          if (((word >> 23) & 0x1) == 0)
12580                                                            {
12581                                                              /* 33222222222211111111110000000000
12582                                                                 10987654321098765432109876543210
12583                                                                 010001x10x0xxxxx110100xxxxxxxxxx
12584                                                                 adclb.  */
12585                                                              return 2061;
12586                                                            }
12587                                                          else
12588                                                            {
12589                                                              /* 33222222222211111111110000000000
12590                                                                 10987654321098765432109876543210
12591                                                                 010001x11x0xxxxx110100xxxxxxxxxx
12592                                                                 sbclb.  */
12593                                                              return 2146;
12594                                                            }
12595                                                        }
12596                                                    }
12597                                                  else
12598                                                    {
12599                                                      if (((word >> 12) & 0x1) == 0)
12600                                                        {
12601                                                          /* 33222222222211111111110000000000
12602                                                             10987654321098765432109876543210
12603                                                             010001x1xx0xxxxx110001xxxxxxxxxx
12604                                                             sabalt.  */
12605                                                          return 2137;
12606                                                        }
12607                                                      else
12608                                                        {
12609                                                          if (((word >> 23) & 0x1) == 0)
12610                                                            {
12611                                                              /* 33222222222211111111110000000000
12612                                                                 10987654321098765432109876543210
12613                                                                 010001x10x0xxxxx110101xxxxxxxxxx
12614                                                                 adclt.  */
12615                                                              return 2062;
12616                                                            }
12617                                                          else
12618                                                            {
12619                                                              /* 33222222222211111111110000000000
12620                                                                 10987654321098765432109876543210
12621                                                                 010001x11x0xxxxx110101xxxxxxxxxx
12622                                                                 sbclt.  */
12623                                                              return 2147;
12624                                                            }
12625                                                        }
12626                                                    }
12627                                                }
12628                                              else
12629                                                {
12630                                                  if (((word >> 12) & 0x1) == 0)
12631                                                    {
12632                                                      if (((word >> 10) & 0x1) == 0)
12633                                                        {
12634                                                          /* 33222222222211111111110000000000
12635                                                             10987654321098765432109876543210
12636                                                             010001x1xx0xxxxx110010xxxxxxxxxx
12637                                                             uabalb.  */
12638                                                          return 2267;
12639                                                        }
12640                                                      else
12641                                                        {
12642                                                          /* 33222222222211111111110000000000
12643                                                             10987654321098765432109876543210
12644                                                             010001x1xx0xxxxx110011xxxxxxxxxx
12645                                                             uabalt.  */
12646                                                          return 2268;
12647                                                        }
12648                                                    }
12649                                                  else
12650                                                    {
12651                                                      if (((word >> 16) & 0x1) == 0)
12652                                                        {
12653                                                          /* 33222222222211111111110000000000
12654                                                             10987654321098765432109876543210
12655                                                             010001x1xx0xxxx011011xxxxxxxxxxx
12656                                                             cadd.  */
12657                                                          return 2070;
12658                                                        }
12659                                                      else
12660                                                        {
12661                                                          /* 33222222222211111111110000000000
12662                                                             10987654321098765432109876543210
12663                                                             010001x1xx0xxxx111011xxxxxxxxxxx
12664                                                             sqcadd.  */
12665                                                          return 2178;
12666                                                        }
12667                                                    }
12668                                                }
12669                                            }
12670                                          else
12671                                            {
12672                                              if (((word >> 22) & 0x1) == 0)
12673                                                {
12674                                                  if (((word >> 23) & 0x1) == 0)
12675                                                    {
12676                                                      /* 33222222222211111111110000000000
12677                                                         10987654321098765432109876543210
12678                                                         110001x1000xxxxx110xxxxxxxxxxxxx
12679                                                         ldnt1w.  */
12680                                                      return 2112;
12681                                                    }
12682                                                  else
12683                                                    {
12684                                                      /* 33222222222211111111110000000000
12685                                                         10987654321098765432109876543210
12686                                                         110001x1100xxxxx110xxxxxxxxxxxxx
12687                                                         ldnt1d.  */
12688                                                      return 2105;
12689                                                    }
12690                                                }
12691                                              else
12692                                                {
12693                                                  if (((word >> 23) & 0x1) == 0)
12694                                                    {
12695                                                      /* 33222222222211111111110000000000
12696                                                         10987654321098765432109876543210
12697                                                         110001x1010xxxxx110xxxxxxxxxxxxx
12698                                                         ld1w.  */
12699                                                      return 1609;
12700                                                    }
12701                                                  else
12702                                                    {
12703                                                      /* 33222222222211111111110000000000
12704                                                         10987654321098765432109876543210
12705                                                         110001x1110xxxxx110xxxxxxxxxxxxx
12706                                                         ld1d.  */
12707                                                      return 1531;
12708                                                    }
12709                                                }
12710                                            }
12711                                        }
12712                                      else
12713                                        {
12714                                          if (((word >> 23) & 0x1) == 0)
12715                                            {
12716                                              if (((word >> 22) & 0x1) == 0)
12717                                                {
12718                                                  /* 33222222222211111111110000000000
12719                                                     10987654321098765432109876543210
12720                                                     x10001x1001xxxxx110xxxxxxxxxxxxx
12721                                                     ld1w.  */
12722                                                  return 1614;
12723                                                }
12724                                              else
12725                                                {
12726                                                  /* 33222222222211111111110000000000
12727                                                     10987654321098765432109876543210
12728                                                     x10001x1011xxxxx110xxxxxxxxxxxxx
12729                                                     ld1w.  */
12730                                                  return 1610;
12731                                                }
12732                                            }
12733                                          else
12734                                            {
12735                                              if (((word >> 31) & 0x1) == 0)
12736                                                {
12737                                                  /* 33222222222211111111110000000000
12738                                                     10987654321098765432109876543210
12739                                                     010001x11x1xxxxx110xxxxxxxxxxxxx
12740                                                     histcnt.  */
12741                                                  return 2101;
12742                                                }
12743                                              else
12744                                                {
12745                                                  if (((word >> 22) & 0x1) == 0)
12746                                                    {
12747                                                      /* 33222222222211111111110000000000
12748                                                         10987654321098765432109876543210
12749                                                         110001x1101xxxxx110xxxxxxxxxxxxx
12750                                                         ld1d.  */
12751                                                      return 1534;
12752                                                    }
12753                                                  else
12754                                                    {
12755                                                      /* 33222222222211111111110000000000
12756                                                         10987654321098765432109876543210
12757                                                         110001x1111xxxxx110xxxxxxxxxxxxx
12758                                                         ld1d.  */
12759                                                      return 1532;
12760                                                    }
12761                                                }
12762                                            }
12763                                        }
12764                                    }
12765                                }
12766                            }
12767                          else
12768                            {
12769                              if (((word >> 14) & 0x1) == 0)
12770                                {
12771                                  if (((word >> 15) & 0x1) == 0)
12772                                    {
12773                                      if (((word >> 21) & 0x1) == 0)
12774                                        {
12775                                          if (((word >> 31) & 0x1) == 0)
12776                                            {
12777                                              if (((word >> 10) & 0x1) == 0)
12778                                                {
12779                                                  if (((word >> 11) & 0x1) == 0)
12780                                                    {
12781                                                      /* 33222222222211111111110000000000
12782                                                         10987654321098765432109876543210
12783                                                         010001x1xx0xxxxx001x00xxxxxxxxxx
12784                                                         sabdlb.  */
12785                                                      return 2138;
12786                                                    }
12787                                                  else
12788                                                    {
12789                                                      /* 33222222222211111111110000000000
12790                                                         10987654321098765432109876543210
12791                                                         010001x1xx0xxxxx001x10xxxxxxxxxx
12792                                                         uabdlb.  */
12793                                                      return 2269;
12794                                                    }
12795                                                }
12796                                              else
12797                                                {
12798                                                  if (((word >> 11) & 0x1) == 0)
12799                                                    {
12800                                                      /* 33222222222211111111110000000000
12801                                                         10987654321098765432109876543210
12802                                                         010001x1xx0xxxxx001x01xxxxxxxxxx
12803                                                         sabdlt.  */
12804                                                      return 2139;
12805                                                    }
12806                                                  else
12807                                                    {
12808                                                      /* 33222222222211111111110000000000
12809                                                         10987654321098765432109876543210
12810                                                         010001x1xx0xxxxx001x11xxxxxxxxxx
12811                                                         uabdlt.  */
12812                                                      return 2270;
12813                                                    }
12814                                                }
12815                                            }
12816                                          else
12817                                            {
12818                                              /* 33222222222211111111110000000000
12819                                                 10987654321098765432109876543210
12820                                                 110001x1xx0xxxxx001xxxxxxxxxxxxx
12821                                                 ldff1sw.  */
12822                                              return 1698;
12823                                            }
12824                                        }
12825                                      else
12826                                        {
12827                                          if (((word >> 31) & 0x1) == 0)
12828                                            {
12829                                              if (((word >> 10) & 0x1) == 0)
12830                                                {
12831                                                  if (((word >> 11) & 0x1) == 0)
12832                                                    {
12833                                                      if (((word >> 12) & 0x1) == 0)
12834                                                        {
12835                                                          /* 33222222222211111111110000000000
12836                                                             10987654321098765432109876543210
12837                                                             010001x1xx1xxxxx001000xxxxxxxxxx
12838                                                             sqshrnb.  */
12839                                                          return 2229;
12840                                                        }
12841                                                      else
12842                                                        {
12843                                                          /* 33222222222211111111110000000000
12844                                                             10987654321098765432109876543210
12845                                                             010001x1xx1xxxxx001100xxxxxxxxxx
12846                                                             uqshrnb.  */
12847                                                          return 2308;
12848                                                        }
12849                                                    }
12850                                                  else
12851                                                    {
12852                                                      if (((word >> 12) & 0x1) == 0)
12853                                                        {
12854                                                          /* 33222222222211111111110000000000
12855                                                             10987654321098765432109876543210
12856                                                             010001x1xx1xxxxx001010xxxxxxxxxx
12857                                                             sqrshrnb.  */
12858                                                          return 2221;
12859                                                        }
12860                                                      else
12861                                                        {
12862                                                          /* 33222222222211111111110000000000
12863                                                             10987654321098765432109876543210
12864                                                             010001x1xx1xxxxx001110xxxxxxxxxx
12865                                                             uqrshrnb.  */
12866                                                          return 2303;
12867                                                        }
12868                                                    }
12869                                                }
12870                                              else
12871                                                {
12872                                                  if (((word >> 11) & 0x1) == 0)
12873                                                    {
12874                                                      if (((word >> 12) & 0x1) == 0)
12875                                                        {
12876                                                          /* 33222222222211111111110000000000
12877                                                             10987654321098765432109876543210
12878                                                             010001x1xx1xxxxx001001xxxxxxxxxx
12879                                                             sqshrnt.  */
12880                                                          return 2230;
12881                                                        }
12882                                                      else
12883                                                        {
12884                                                          /* 33222222222211111111110000000000
12885                                                             10987654321098765432109876543210
12886                                                             010001x1xx1xxxxx001101xxxxxxxxxx
12887                                                             uqshrnt.  */
12888                                                          return 2309;
12889                                                        }
12890                                                    }
12891                                                  else
12892                                                    {
12893                                                      if (((word >> 12) & 0x1) == 0)
12894                                                        {
12895                                                          /* 33222222222211111111110000000000
12896                                                             10987654321098765432109876543210
12897                                                             010001x1xx1xxxxx001011xxxxxxxxxx
12898                                                             sqrshrnt.  */
12899                                                          return 2222;
12900                                                        }
12901                                                      else
12902                                                        {
12903                                                          /* 33222222222211111111110000000000
12904                                                             10987654321098765432109876543210
12905                                                             010001x1xx1xxxxx001111xxxxxxxxxx
12906                                                             uqrshrnt.  */
12907                                                          return 2304;
12908                                                        }
12909                                                    }
12910                                                }
12911                                            }
12912                                          else
12913                                            {
12914                                              /* 33222222222211111111110000000000
12915                                                 10987654321098765432109876543210
12916                                                 110001x1xx1xxxxx001xxxxxxxxxxxxx
12917                                                 ldff1sw.  */
12918                                              return 1699;
12919                                            }
12920                                        }
12921                                    }
12922                                  else
12923                                    {
12924                                      if (((word >> 21) & 0x1) == 0)
12925                                        {
12926                                          if (((word >> 31) & 0x1) == 0)
12927                                            {
12928                                              if (((word >> 10) & 0x1) == 0)
12929                                                {
12930                                                  if (((word >> 11) & 0x1) == 0)
12931                                                    {
12932                                                      if (((word >> 12) & 0x1) == 0)
12933                                                        {
12934                                                          /* 33222222222211111111110000000000
12935                                                             10987654321098765432109876543210
12936                                                             010001x1xx0xxxxx101000xxxxxxxxxx
12937                                                             sshllb.  */
12938                                                          return 2245;
12939                                                        }
12940                                                      else
12941                                                        {
12942                                                          /* 33222222222211111111110000000000
12943                                                             10987654321098765432109876543210
12944                                                             010001x1xx0xxxxx101100xxxxxxxxxx
12945                                                             bext.  */
12946                                                          return 2350;
12947                                                        }
12948                                                    }
12949                                                  else
12950                                                    {
12951                                                      if (((word >> 12) & 0x1) == 0)
12952                                                        {
12953                                                          /* 33222222222211111111110000000000
12954                                                             10987654321098765432109876543210
12955                                                             010001x1xx0xxxxx101010xxxxxxxxxx
12956                                                             ushllb.  */
12957                                                          return 2321;
12958                                                        }
12959                                                      else
12960                                                        {
12961                                                          /* 33222222222211111111110000000000
12962                                                             10987654321098765432109876543210
12963                                                             010001x1xx0xxxxx101110xxxxxxxxxx
12964                                                             bgrp.  */
12965                                                          return 2351;
12966                                                        }
12967                                                    }
12968                                                }
12969                                              else
12970                                                {
12971                                                  if (((word >> 11) & 0x1) == 0)
12972                                                    {
12973                                                      if (((word >> 12) & 0x1) == 0)
12974                                                        {
12975                                                          /* 33222222222211111111110000000000
12976                                                             10987654321098765432109876543210
12977                                                             010001x1xx0xxxxx101001xxxxxxxxxx
12978                                                             sshllt.  */
12979                                                          return 2246;
12980                                                        }
12981                                                      else
12982                                                        {
12983                                                          /* 33222222222211111111110000000000
12984                                                             10987654321098765432109876543210
12985                                                             010001x1xx0xxxxx101101xxxxxxxxxx
12986                                                             bdep.  */
12987                                                          return 2349;
12988                                                        }
12989                                                    }
12990                                                  else
12991                                                    {
12992                                                      /* 33222222222211111111110000000000
12993                                                         10987654321098765432109876543210
12994                                                         010001x1xx0xxxxx101x11xxxxxxxxxx
12995                                                         ushllt.  */
12996                                                      return 2322;
12997                                                    }
12998                                                }
12999                                            }
13000                                          else
13001                                            {
13002                                              /* 33222222222211111111110000000000
13003                                                 10987654321098765432109876543210
13004                                                 110001x1xx0xxxxx101xxxxxxxxxxxxx
13005                                                 ldff1sw.  */
13006                                              return 1700;
13007                                            }
13008                                        }
13009                                      else
13010                                        {
13011                                          if (((word >> 22) & 0x1) == 0)
13012                                            {
13013                                              if (((word >> 31) & 0x1) == 0)
13014                                                {
13015                                                  /* 33222222222211111111110000000000
13016                                                     10987654321098765432109876543210
13017                                                     010001x1x01xxxxx101xxxxxxxxxxxxx
13018                                                     histseg.  */
13019                                                  return 2102;
13020                                                }
13021                                              else
13022                                                {
13023                                                  /* 33222222222211111111110000000000
13024                                                     10987654321098765432109876543210
13025                                                     110001x1x01xxxxx101xxxxxxxxxxxxx
13026                                                     ldff1sw.  */
13027                                                  return 1702;
13028                                                }
13029                                            }
13030                                          else
13031                                            {
13032                                              /* 33222222222211111111110000000000
13033                                                 10987654321098765432109876543210
13034                                                 x10001x1x11xxxxx101xxxxxxxxxxxxx
13035                                                 ldff1sw.  */
13036                                              return 1701;
13037                                            }
13038                                        }
13039                                    }
13040                                }
13041                              else
13042                                {
13043                                  if (((word >> 15) & 0x1) == 0)
13044                                    {
13045                                      if (((word >> 21) & 0x1) == 0)
13046                                        {
13047                                          if (((word >> 31) & 0x1) == 0)
13048                                            {
13049                                              if (((word >> 10) & 0x1) == 0)
13050                                                {
13051                                                  if (((word >> 11) & 0x1) == 0)
13052                                                    {
13053                                                      if (((word >> 12) & 0x1) == 0)
13054                                                        {
13055                                                          /* 33222222222211111111110000000000
13056                                                             10987654321098765432109876543210
13057                                                             010001x1xx0xxxxx011000xxxxxxxxxx
13058                                                             sqdmullb.  */
13059                                                          return 2199;
13060                                                        }
13061                                                      else
13062                                                        {
13063                                                          /* 33222222222211111111110000000000
13064                                                             10987654321098765432109876543210
13065                                                             010001x1xx0xxxxx011100xxxxxxxxxx
13066                                                             smullb.  */
13067                                                          return 2171;
13068                                                        }
13069                                                    }
13070                                                  else
13071                                                    {
13072                                                      if (((word >> 12) & 0x1) == 0)
13073                                                        {
13074                                                          if (((word >> 22) & 0x1) == 0)
13075                                                            {
13076                                                              /* 33222222222211111111110000000000
13077                                                                 10987654321098765432109876543210
13078                                                                 010001x1x00xxxxx011010xxxxxxxxxx
13079                                                                 pmullb.  */
13080                                                              return 2346;
13081                                                            }
13082                                                          else
13083                                                            {
13084                                                              /* 33222222222211111111110000000000
13085                                                                 10987654321098765432109876543210
13086                                                                 010001x1x10xxxxx011010xxxxxxxxxx
13087                                                                 pmullb.  */
13088                                                              return 2127;
13089                                                            }
13090                                                        }
13091                                                      else
13092                                                        {
13093                                                          /* 33222222222211111111110000000000
13094                                                             10987654321098765432109876543210
13095                                                             010001x1xx0xxxxx011110xxxxxxxxxx
13096                                                             umullb.  */
13097                                                          return 2296;
13098                                                        }
13099                                                    }
13100                                                }
13101                                              else
13102                                                {
13103                                                  if (((word >> 11) & 0x1) == 0)
13104                                                    {
13105                                                      if (((word >> 12) & 0x1) == 0)
13106                                                        {
13107                                                          /* 33222222222211111111110000000000
13108                                                             10987654321098765432109876543210
13109                                                             010001x1xx0xxxxx011001xxxxxxxxxx
13110                                                             sqdmullt.  */
13111                                                          return 2202;
13112                                                        }
13113                                                      else
13114                                                        {
13115                                                          /* 33222222222211111111110000000000
13116                                                             10987654321098765432109876543210
13117                                                             010001x1xx0xxxxx011101xxxxxxxxxx
13118                                                             smullt.  */
13119                                                          return 2174;
13120                                                        }
13121                                                    }
13122                                                  else
13123                                                    {
13124                                                      if (((word >> 12) & 0x1) == 0)
13125                                                        {
13126                                                          if (((word >> 22) & 0x1) == 0)
13127                                                            {
13128                                                              /* 33222222222211111111110000000000
13129                                                                 10987654321098765432109876543210
13130                                                                 010001x1x00xxxxx011011xxxxxxxxxx
13131                                                                 pmullt.  */
13132                                                              return 2347;
13133                                                            }
13134                                                          else
13135                                                            {
13136                                                              /* 33222222222211111111110000000000
13137                                                                 10987654321098765432109876543210
13138                                                                 010001x1x10xxxxx011011xxxxxxxxxx
13139                                                                 pmullt.  */
13140                                                              return 2128;
13141                                                            }
13142                                                        }
13143                                                      else
13144                                                        {
13145                                                          /* 33222222222211111111110000000000
13146                                                             10987654321098765432109876543210
13147                                                             010001x1xx0xxxxx011111xxxxxxxxxx
13148                                                             umullt.  */
13149                                                          return 2299;
13150                                                        }
13151                                                    }
13152                                                }
13153                                            }
13154                                          else
13155                                            {
13156                                              if (((word >> 23) & 0x1) == 0)
13157                                                {
13158                                                  /* 33222222222211111111110000000000
13159                                                     10987654321098765432109876543210
13160                                                     110001x10x0xxxxx011xxxxxxxxxxxxx
13161                                                     ldff1w.  */
13162                                                  return 1709;
13163                                                }
13164                                              else
13165                                                {
13166                                                  /* 33222222222211111111110000000000
13167                                                     10987654321098765432109876543210
13168                                                     110001x11x0xxxxx011xxxxxxxxxxxxx
13169                                                     ldff1d.  */
13170                                                  return 1654;
13171                                                }
13172                                            }
13173                                        }
13174                                      else
13175                                        {
13176                                          if (((word >> 31) & 0x1) == 0)
13177                                            {
13178                                              if (((word >> 10) & 0x1) == 0)
13179                                                {
13180                                                  if (((word >> 11) & 0x1) == 0)
13181                                                    {
13182                                                      if (((word >> 12) & 0x1) == 0)
13183                                                        {
13184                                                          /* 33222222222211111111110000000000
13185                                                             10987654321098765432109876543210
13186                                                             010001x1xx1xxxxx011000xxxxxxxxxx
13187                                                             addhnb.  */
13188                                                          return 2063;
13189                                                        }
13190                                                      else
13191                                                        {
13192                                                          /* 33222222222211111111110000000000
13193                                                             10987654321098765432109876543210
13194                                                             010001x1xx1xxxxx011100xxxxxxxxxx
13195                                                             subhnb.  */
13196                                                          return 2261;
13197                                                        }
13198                                                    }
13199                                                  else
13200                                                    {
13201                                                      if (((word >> 12) & 0x1) == 0)
13202                                                        {
13203                                                          /* 33222222222211111111110000000000
13204                                                             10987654321098765432109876543210
13205                                                             010001x1xx1xxxxx011010xxxxxxxxxx
13206                                                             raddhnb.  */
13207                                                          return 2129;
13208                                                        }
13209                                                      else
13210                                                        {
13211                                                          /* 33222222222211111111110000000000
13212                                                             10987654321098765432109876543210
13213                                                             010001x1xx1xxxxx011110xxxxxxxxxx
13214                                                             rsubhnb.  */
13215                                                          return 2133;
13216                                                        }
13217                                                    }
13218                                                }
13219                                              else
13220                                                {
13221                                                  if (((word >> 11) & 0x1) == 0)
13222                                                    {
13223                                                      if (((word >> 12) & 0x1) == 0)
13224                                                        {
13225                                                          /* 33222222222211111111110000000000
13226                                                             10987654321098765432109876543210
13227                                                             010001x1xx1xxxxx011001xxxxxxxxxx
13228                                                             addhnt.  */
13229                                                          return 2064;
13230                                                        }
13231                                                      else
13232                                                        {
13233                                                          /* 33222222222211111111110000000000
13234                                                             10987654321098765432109876543210
13235                                                             010001x1xx1xxxxx011101xxxxxxxxxx
13236                                                             subhnt.  */
13237                                                          return 2262;
13238                                                        }
13239                                                    }
13240                                                  else
13241                                                    {
13242                                                      if (((word >> 12) & 0x1) == 0)
13243                                                        {
13244                                                          /* 33222222222211111111110000000000
13245                                                             10987654321098765432109876543210
13246                                                             010001x1xx1xxxxx011011xxxxxxxxxx
13247                                                             raddhnt.  */
13248                                                          return 2130;
13249                                                        }
13250                                                      else
13251                                                        {
13252                                                          /* 33222222222211111111110000000000
13253                                                             10987654321098765432109876543210
13254                                                             010001x1xx1xxxxx011111xxxxxxxxxx
13255                                                             rsubhnt.  */
13256                                                          return 2134;
13257                                                        }
13258                                                    }
13259                                                }
13260                                            }
13261                                          else
13262                                            {
13263                                              if (((word >> 23) & 0x1) == 0)
13264                                                {
13265                                                  /* 33222222222211111111110000000000
13266                                                     10987654321098765432109876543210
13267                                                     110001x10x1xxxxx011xxxxxxxxxxxxx
13268                                                     ldff1w.  */
13269                                                  return 1710;
13270                                                }
13271                                              else
13272                                                {
13273                                                  /* 33222222222211111111110000000000
13274                                                     10987654321098765432109876543210
13275                                                     110001x11x1xxxxx011xxxxxxxxxxxxx
13276                                                     ldff1d.  */
13277                                                  return 1655;
13278                                                }
13279                                            }
13280                                        }
13281                                    }
13282                                  else
13283                                    {
13284                                      if (((word >> 21) & 0x1) == 0)
13285                                        {
13286                                          if (((word >> 31) & 0x1) == 0)
13287                                            {
13288                                              if (((word >> 10) & 0x1) == 0)
13289                                                {
13290                                                  if (((word >> 11) & 0x1) == 0)
13291                                                    {
13292                                                      if (((word >> 12) & 0x1) == 0)
13293                                                        {
13294                                                          /* 33222222222211111111110000000000
13295                                                             10987654321098765432109876543210
13296                                                             010001x1xx0xxxxx111000xxxxxxxxxx
13297                                                             ssra.  */
13298                                                          return 2247;
13299                                                        }
13300                                                      else
13301                                                        {
13302                                                          /* 33222222222211111111110000000000
13303                                                             10987654321098765432109876543210
13304                                                             010001x1xx0xxxxx111100xxxxxxxxxx
13305                                                             sri.  */
13306                                                          return 2240;
13307                                                        }
13308                                                    }
13309                                                  else
13310                                                    {
13311                                                      if (((word >> 12) & 0x1) == 0)
13312                                                        {
13313                                                          /* 33222222222211111111110000000000
13314                                                             10987654321098765432109876543210
13315                                                             010001x1xx0xxxxx111010xxxxxxxxxx
13316                                                             srsra.  */
13317                                                          return 2244;
13318                                                        }
13319                                                      else
13320                                                        {
13321                                                          /* 33222222222211111111110000000000
13322                                                             10987654321098765432109876543210
13323                                                             010001x1xx0xxxxx111110xxxxxxxxxx
13324                                                             saba.  */
13325                                                          return 2135;
13326                                                        }
13327                                                    }
13328                                                }
13329                                              else
13330                                                {
13331                                                  if (((word >> 11) & 0x1) == 0)
13332                                                    {
13333                                                      if (((word >> 12) & 0x1) == 0)
13334                                                        {
13335                                                          /* 33222222222211111111110000000000
13336                                                             10987654321098765432109876543210
13337                                                             010001x1xx0xxxxx111001xxxxxxxxxx
13338                                                             usra.  */
13339                                                          return 2324;
13340                                                        }
13341                                                      else
13342                                                        {
13343                                                          /* 33222222222211111111110000000000
13344                                                             10987654321098765432109876543210
13345                                                             010001x1xx0xxxxx111101xxxxxxxxxx
13346                                                             sli.  */
13347                                                          return 2153;
13348                                                        }
13349                                                    }
13350                                                  else
13351                                                    {
13352                                                      if (((word >> 12) & 0x1) == 0)
13353                                                        {
13354                                                          /* 33222222222211111111110000000000
13355                                                             10987654321098765432109876543210
13356                                                             010001x1xx0xxxxx111011xxxxxxxxxx
13357                                                             ursra.  */
13358                                                          return 2320;
13359                                                        }
13360                                                      else
13361                                                        {
13362                                                          /* 33222222222211111111110000000000
13363                                                             10987654321098765432109876543210
13364                                                             010001x1xx0xxxxx111111xxxxxxxxxx
13365                                                             uaba.  */
13366                                                          return 2266;
13367                                                        }
13368                                                    }
13369                                                }
13370                                            }
13371                                          else
13372                                            {
13373                                              if (((word >> 22) & 0x1) == 0)
13374                                                {
13375                                                  if (((word >> 23) & 0x1) == 0)
13376                                                    {
13377                                                      /* 33222222222211111111110000000000
13378                                                         10987654321098765432109876543210
13379                                                         110001x1000xxxxx111xxxxxxxxxxxxx
13380                                                         prfw.  */
13381                                                      return 1805;
13382                                                    }
13383                                                  else
13384                                                    {
13385                                                      /* 33222222222211111111110000000000
13386                                                         10987654321098765432109876543210
13387                                                         110001x1100xxxxx111xxxxxxxxxxxxx
13388                                                         prfd.  */
13389                                                      return 1791;
13390                                                    }
13391                                                }
13392                                              else
13393                                                {
13394                                                  if (((word >> 23) & 0x1) == 0)
13395                                                    {
13396                                                      /* 33222222222211111111110000000000
13397                                                         10987654321098765432109876543210
13398                                                         110001x1010xxxxx111xxxxxxxxxxxxx
13399                                                         ldff1w.  */
13400                                                      return 1711;
13401                                                    }
13402                                                  else
13403                                                    {
13404                                                      /* 33222222222211111111110000000000
13405                                                         10987654321098765432109876543210
13406                                                         110001x1110xxxxx111xxxxxxxxxxxxx
13407                                                         ldff1d.  */
13408                                                      return 1656;
13409                                                    }
13410                                                }
13411                                            }
13412                                        }
13413                                      else
13414                                        {
13415                                          if (((word >> 22) & 0x1) == 0)
13416                                            {
13417                                              if (((word >> 23) & 0x1) == 0)
13418                                                {
13419                                                  if (((word >> 31) & 0x1) == 0)
13420                                                    {
13421                                                      if (((word >> 10) & 0x1) == 0)
13422                                                        {
13423                                                          if (((word >> 12) & 0x1) == 0)
13424                                                            {
13425                                                              if (((word >> 16) & 0x1) == 0)
13426                                                                {
13427                                                                  if (((word >> 17) & 0x1) == 0)
13428                                                                    {
13429                                                                      /* 33222222222211111111110000000000
13430                                                                         10987654321098765432109876543210
13431                                                                         010001x1001xxx001110x0xxxxxxxxxx
13432                                                                         aesmc.  */
13433                                                                      return 2345;
13434                                                                    }
13435                                                                  else
13436                                                                    {
13437                                                                      /* 33222222222211111111110000000000
13438                                                                         10987654321098765432109876543210
13439                                                                         010001x1001xxx101110x0xxxxxxxxxx
13440                                                                         aese.  */
13441                                                                      return 2343;
13442                                                                    }
13443                                                                }
13444                                                              else
13445                                                                {
13446                                                                  /* 33222222222211111111110000000000
13447                                                                     10987654321098765432109876543210
13448                                                                     010001x1001xxxx11110x0xxxxxxxxxx
13449                                                                     sm4e.  */
13450                                                                  return 2340;
13451                                                                }
13452                                                            }
13453                                                          else
13454                                                            {
13455                                                              /* 33222222222211111111110000000000
13456                                                                 10987654321098765432109876543210
13457                                                                 010001x1001xxxxx1111x0xxxxxxxxxx
13458                                                                 sm4ekey.  */
13459                                                              return 2341;
13460                                                            }
13461                                                        }
13462                                                      else
13463                                                        {
13464                                                          if (((word >> 12) & 0x1) == 0)
13465                                                            {
13466                                                              if (((word >> 17) & 0x1) == 0)
13467                                                                {
13468                                                                  /* 33222222222211111111110000000000
13469                                                                     10987654321098765432109876543210
13470                                                                     010001x1001xxx0x1110x1xxxxxxxxxx
13471                                                                     aesimc.  */
13472                                                                  return 2344;
13473                                                                }
13474                                                              else
13475                                                                {
13476                                                                  /* 33222222222211111111110000000000
13477                                                                     10987654321098765432109876543210
13478                                                                     010001x1001xxx1x1110x1xxxxxxxxxx
13479                                                                     aesd.  */
13480                                                                  return 2342;
13481                                                                }
13482                                                            }
13483                                                          else
13484                                                            {
13485                                                              /* 33222222222211111111110000000000
13486                                                                 10987654321098765432109876543210
13487                                                                 010001x1001xxxxx1111x1xxxxxxxxxx
13488                                                                 rax1.  */
13489                                                              return 2348;
13490                                                            }
13491                                                        }
13492                                                    }
13493                                                  else
13494                                                    {
13495                                                      /* 33222222222211111111110000000000
13496                                                         10987654321098765432109876543210
13497                                                         110001x1001xxxxx111xxxxxxxxxxxxx
13498                                                         ldff1w.  */
13499                                                      return 1714;
13500                                                    }
13501                                                }
13502                                              else
13503                                                {
13504                                                  /* 33222222222211111111110000000000
13505                                                     10987654321098765432109876543210
13506                                                     x10001x1101xxxxx111xxxxxxxxxxxxx
13507                                                     ldff1d.  */
13508                                                  return 1658;
13509                                                }
13510                                            }
13511                                          else
13512                                            {
13513                                              if (((word >> 23) & 0x1) == 0)
13514                                                {
13515                                                  /* 33222222222211111111110000000000
13516                                                     10987654321098765432109876543210
13517                                                     x10001x1011xxxxx111xxxxxxxxxxxxx
13518                                                     ldff1w.  */
13519                                                  return 1712;
13520                                                }
13521                                              else
13522                                                {
13523                                                  /* 33222222222211111111110000000000
13524                                                     10987654321098765432109876543210
13525                                                     x10001x1111xxxxx111xxxxxxxxxxxxx
13526                                                     ldff1d.  */
13527                                                  return 1657;
13528                                                }
13529                                            }
13530                                        }
13531                                    }
13532                                }
13533                            }
13534                        }
13535                    }
13536                  else
13537                    {
13538                      if (((word >> 15) & 0x1) == 0)
13539                        {
13540                          if (((word >> 14) & 0x1) == 0)
13541                            {
13542                              if (((word >> 13) & 0x1) == 0)
13543                                {
13544                                  if (((word >> 30) & 0x1) == 0)
13545                                    {
13546                                      if (((word >> 21) & 0x1) == 0)
13547                                        {
13548                                          if (((word >> 31) & 0x1) == 0)
13549                                            {
13550                                              if (((word >> 4) & 0x1) == 0)
13551                                                {
13552                                                  /* 33222222222211111111110000000000
13553                                                     10987654321098765432109876543210
13554                                                     001001x1xx0xxxxx000xxxxxxxx0xxxx
13555                                                     cmpge.  */
13556                                                  return 1337;
13557                                                }
13558                                              else
13559                                                {
13560                                                  /* 33222222222211111111110000000000
13561                                                     10987654321098765432109876543210
13562                                                     001001x1xx0xxxxx000xxxxxxxx1xxxx
13563                                                     cmpgt.  */
13564                                                  return 1340;
13565                                                }
13566                                            }
13567                                          else
13568                                            {
13569                                              if (((word >> 23) & 0x1) == 0)
13570                                                {
13571                                                  /* 33222222222211111111110000000000
13572                                                     10987654321098765432109876543210
13573                                                     101001x10x0xxxxx000xxxxxxxxxxxxx
13574                                                     ld1rqw.  */
13575                                                  return 1564;
13576                                                }
13577                                              else
13578                                                {
13579                                                  /* 33222222222211111111110000000000
13580                                                     10987654321098765432109876543210
13581                                                     101001x11x0xxxxx000xxxxxxxxxxxxx
13582                                                     ld1rqd.  */
13583                                                  return 1560;
13584                                                }
13585                                            }
13586                                        }
13587                                      else
13588                                        {
13589                                          if (((word >> 31) & 0x1) == 0)
13590                                            {
13591                                              if (((word >> 4) & 0x1) == 0)
13592                                                {
13593                                                  if (((word >> 10) & 0x1) == 0)
13594                                                    {
13595                                                      if (((word >> 11) & 0x1) == 0)
13596                                                        {
13597                                                          if (((word >> 12) & 0x1) == 0)
13598                                                            {
13599                                                              /* 33222222222211111111110000000000
13600                                                                 10987654321098765432109876543210
13601                                                                 001001x1xx1xxxxx000000xxxxx0xxxx
13602                                                                 whilege.  */
13603                                                              return 2329;
13604                                                            }
13605                                                          else
13606                                                            {
13607                                                              /* 33222222222211111111110000000000
13608                                                                 10987654321098765432109876543210
13609                                                                 001001x1xx1xxxxx000100xxxxx0xxxx
13610                                                                 whilege.  */
13611                                                              return 2330;
13612                                                            }
13613                                                        }
13614                                                      else
13615                                                        {
13616                                                          if (((word >> 12) & 0x1) == 0)
13617                                                            {
13618                                                              /* 33222222222211111111110000000000
13619                                                                 10987654321098765432109876543210
13620                                                                 001001x1xx1xxxxx000010xxxxx0xxxx
13621                                                                 whilehs.  */
13622                                                              return 2335;
13623                                                            }
13624                                                          else
13625                                                            {
13626                                                              /* 33222222222211111111110000000000
13627                                                                 10987654321098765432109876543210
13628                                                                 001001x1xx1xxxxx000110xxxxx0xxxx
13629                                                                 whilehs.  */
13630                                                              return 2336;
13631                                                            }
13632                                                        }
13633                                                    }
13634                                                  else
13635                                                    {
13636                                                      if (((word >> 11) & 0x1) == 0)
13637                                                        {
13638                                                          if (((word >> 12) & 0x1) == 0)
13639                                                            {
13640                                                              /* 33222222222211111111110000000000
13641                                                                 10987654321098765432109876543210
13642                                                                 001001x1xx1xxxxx000001xxxxx0xxxx
13643                                                                 whilelt.  */
13644                                                              return 2041;
13645                                                            }
13646                                                          else
13647                                                            {
13648                                                              /* 33222222222211111111110000000000
13649                                                                 10987654321098765432109876543210
13650                                                                 001001x1xx1xxxxx000101xxxxx0xxxx
13651                                                                 whilelt.  */
13652                                                              return 2042;
13653                                                            }
13654                                                        }
13655                                                      else
13656                                                        {
13657                                                          if (((word >> 12) & 0x1) == 0)
13658                                                            {
13659                                                              /* 33222222222211111111110000000000
13660                                                                 10987654321098765432109876543210
13661                                                                 001001x1xx1xxxxx000011xxxxx0xxxx
13662                                                                 whilelo.  */
13663                                                              return 2037;
13664                                                            }
13665                                                          else
13666                                                            {
13667                                                              /* 33222222222211111111110000000000
13668                                                                 10987654321098765432109876543210
13669                                                                 001001x1xx1xxxxx000111xxxxx0xxxx
13670                                                                 whilelo.  */
13671                                                              return 2038;
13672                                                            }
13673                                                        }
13674                                                    }
13675                                                }
13676                                              else
13677                                                {
13678                                                  if (((word >> 10) & 0x1) == 0)
13679                                                    {
13680                                                      if (((word >> 11) & 0x1) == 0)
13681                                                        {
13682                                                          if (((word >> 12) & 0x1) == 0)
13683                                                            {
13684                                                              /* 33222222222211111111110000000000
13685                                                                 10987654321098765432109876543210
13686                                                                 001001x1xx1xxxxx000000xxxxx1xxxx
13687                                                                 whilegt.  */
13688                                                              return 2331;
13689                                                            }
13690                                                          else
13691                                                            {
13692                                                              /* 33222222222211111111110000000000
13693                                                                 10987654321098765432109876543210
13694                                                                 001001x1xx1xxxxx000100xxxxx1xxxx
13695                                                                 whilegt.  */
13696                                                              return 2332;
13697                                                            }
13698                                                        }
13699                                                      else
13700                                                        {
13701                                                          if (((word >> 12) & 0x1) == 0)
13702                                                            {
13703                                                              /* 33222222222211111111110000000000
13704                                                                 10987654321098765432109876543210
13705                                                                 001001x1xx1xxxxx000010xxxxx1xxxx
13706                                                                 whilehi.  */
13707                                                              return 2333;
13708                                                            }
13709                                                          else
13710                                                            {
13711                                                              /* 33222222222211111111110000000000
13712                                                                 10987654321098765432109876543210
13713                                                                 001001x1xx1xxxxx000110xxxxx1xxxx
13714                                                                 whilehi.  */
13715                                                              return 2334;
13716                                                            }
13717                                                        }
13718                                                    }
13719                                                  else
13720                                                    {
13721                                                      if (((word >> 11) & 0x1) == 0)
13722                                                        {
13723                                                          if (((word >> 12) & 0x1) == 0)
13724                                                            {
13725                                                              /* 33222222222211111111110000000000
13726                                                                 10987654321098765432109876543210
13727                                                                 001001x1xx1xxxxx000001xxxxx1xxxx
13728                                                                 whilele.  */
13729                                                              return 2035;
13730                                                            }
13731                                                          else
13732                                                            {
13733                                                              /* 33222222222211111111110000000000
13734                                                                 10987654321098765432109876543210
13735                                                                 001001x1xx1xxxxx000101xxxxx1xxxx
13736                                                                 whilele.  */
13737                                                              return 2036;
13738                                                            }
13739                                                        }
13740                                                      else
13741                                                        {
13742                                                          if (((word >> 12) & 0x1) == 0)
13743                                                            {
13744                                                              /* 33222222222211111111110000000000
13745                                                                 10987654321098765432109876543210
13746                                                                 001001x1xx1xxxxx000011xxxxx1xxxx
13747                                                                 whilels.  */
13748                                                              return 2039;
13749                                                            }
13750                                                          else
13751                                                            {
13752                                                              /* 33222222222211111111110000000000
13753                                                                 10987654321098765432109876543210
13754                                                                 001001x1xx1xxxxx000111xxxxx1xxxx
13755                                                                 whilels.  */
13756                                                              return 2040;
13757                                                            }
13758                                                        }
13759                                                    }
13760                                                }
13761                                            }
13762                                          else
13763                                            {
13764                                              if (((word >> 23) & 0x1) == 0)
13765                                                {
13766                                                  /* 33222222222211111111110000000000
13767                                                     10987654321098765432109876543210
13768                                                     101001x10x1xxxxx000xxxxxxxxxxxxx
13769                                                     ld1row.  */
13770                                                  return 2477;
13771                                                }
13772                                              else
13773                                                {
13774                                                  /* 33222222222211111111110000000000
13775                                                     10987654321098765432109876543210
13776                                                     101001x11x1xxxxx000xxxxxxxxxxxxx
13777                                                     ld1rod.  */
13778                                                  return 2478;
13779                                                }
13780                                            }
13781                                        }
13782                                    }
13783                                  else
13784                                    {
13785                                      if (((word >> 31) & 0x1) == 0)
13786                                        {
13787                                          if (((word >> 21) & 0x1) == 0)
13788                                            {
13789                                              if (((word >> 10) & 0x1) == 0)
13790                                                {
13791                                                  if (((word >> 11) & 0x1) == 0)
13792                                                    {
13793                                                      /* 33222222222211111111110000000000
13794                                                         10987654321098765432109876543210
13795                                                         011001x1xx0xxxxx000x00xxxxxxxxxx
13796                                                         fadd.  */
13797                                                      return 1395;
13798                                                    }
13799                                                  else
13800                                                    {
13801                                                      if (((word >> 12) & 0x1) == 0)
13802                                                        {
13803                                                          /* 33222222222211111111110000000000
13804                                                             10987654321098765432109876543210
13805                                                             011001x1xx0xxxxx000010xxxxxxxxxx
13806                                                             fmul.  */
13807                                                          return 1462;
13808                                                        }
13809                                                      else
13810                                                        {
13811                                                          /* 33222222222211111111110000000000
13812                                                             10987654321098765432109876543210
13813                                                             011001x1xx0xxxxx000110xxxxxxxxxx
13814                                                             frecps.  */
13815                                                          return 1475;
13816                                                        }
13817                                                    }
13818                                                }
13819                                              else
13820                                                {
13821                                                  if (((word >> 11) & 0x1) == 0)
13822                                                    {
13823                                                      /* 33222222222211111111110000000000
13824                                                         10987654321098765432109876543210
13825                                                         011001x1xx0xxxxx000x01xxxxxxxxxx
13826                                                         fsub.  */
13827                                                      return 1488;
13828                                                    }
13829                                                  else
13830                                                    {
13831                                                      if (((word >> 12) & 0x1) == 0)
13832                                                        {
13833                                                          /* 33222222222211111111110000000000
13834                                                             10987654321098765432109876543210
13835                                                             011001x1xx0xxxxx000011xxxxxxxxxx
13836                                                             ftsmul.  */
13837                                                          return 1494;
13838                                                        }
13839                                                      else
13840                                                        {
13841                                                          /* 33222222222211111111110000000000
13842                                                             10987654321098765432109876543210
13843                                                             011001x1xx0xxxxx000111xxxxxxxxxx
13844                                                             frsqrts.  */
13845                                                          return 1485;
13846                                                        }
13847                                                    }
13848                                                }
13849                                            }
13850                                          else
13851                                            {
13852                                              /* 33222222222211111111110000000000
13853                                                 10987654321098765432109876543210
13854                                                 011001x1xx1xxxxx000xxxxxxxxxxxxx
13855                                                 fmla.  */
13856                                              return 1453;
13857                                            }
13858                                        }
13859                                      else
13860                                        {
13861                                          /* 33222222222211111111110000000000
13862                                             10987654321098765432109876543210
13863                                             111001x1xxxxxxxx000xxxxxxxxxxxxx
13864                                             str.  */
13865                                          return 1956;
13866                                        }
13867                                    }
13868                                }
13869                              else
13870                                {
13871                                  if (((word >> 21) & 0x1) == 0)
13872                                    {
13873                                      if (((word >> 30) & 0x1) == 0)
13874                                        {
13875                                          if (((word >> 31) & 0x1) == 0)
13876                                            {
13877                                              if (((word >> 4) & 0x1) == 0)
13878                                                {
13879                                                  /* 33222222222211111111110000000000
13880                                                     10987654321098765432109876543210
13881                                                     001001x1xx0xxxxx001xxxxxxxx0xxxx
13882                                                     cmplt.  */
13883                                                  return 1354;
13884                                                }
13885                                              else
13886                                                {
13887                                                  /* 33222222222211111111110000000000
13888                                                     10987654321098765432109876543210
13889                                                     001001x1xx0xxxxx001xxxxxxxx1xxxx
13890                                                     cmple.  */
13891                                                  return 1348;
13892                                                }
13893                                            }
13894                                          else
13895                                            {
13896                                              if (((word >> 23) & 0x1) == 0)
13897                                                {
13898                                                  /* 33222222222211111111110000000000
13899                                                     10987654321098765432109876543210
13900                                                     101001x10x0xxxxx001xxxxxxxxxxxxx
13901                                                     ld1rqw.  */
13902                                                  return 1563;
13903                                                }
13904                                              else
13905                                                {
13906                                                  /* 33222222222211111111110000000000
13907                                                     10987654321098765432109876543210
13908                                                     101001x11x0xxxxx001xxxxxxxxxxxxx
13909                                                     ld1rqd.  */
13910                                                  return 1559;
13911                                                }
13912                                            }
13913                                        }
13914                                      else
13915                                        {
13916                                          if (((word >> 31) & 0x1) == 0)
13917                                            {
13918                                              if (((word >> 16) & 0x1) == 0)
13919                                                {
13920                                                  if (((word >> 17) & 0x1) == 0)
13921                                                    {
13922                                                      if (((word >> 18) & 0x1) == 0)
13923                                                        {
13924                                                          if (((word >> 19) & 0x1) == 0)
13925                                                            {
13926                                                              if (((word >> 20) & 0x1) == 0)
13927                                                                {
13928                                                                  /* 33222222222211111111110000000000
13929                                                                     10987654321098765432109876543210
13930                                                                     011001x1xx000000001xxxxxxxxxxxxx
13931                                                                     faddv.  */
13932                                                                  return 1399;
13933                                                                }
13934                                                              else
13935                                                                {
13936                                                                  if (((word >> 4) & 0x1) == 0)
13937                                                                    {
13938                                                                      /* 33222222222211111111110000000000
13939                                                                         10987654321098765432109876543210
13940                                                                         011001x1xx010000001xxxxxxxx0xxxx
13941                                                                         fcmge.  */
13942                                                                      return 1406;
13943                                                                    }
13944                                                                  else
13945                                                                    {
13946                                                                      /* 33222222222211111111110000000000
13947                                                                         10987654321098765432109876543210
13948                                                                         011001x1xx010000001xxxxxxxx1xxxx
13949                                                                         fcmgt.  */
13950                                                                      return 1408;
13951                                                                    }
13952                                                                }
13953                                                            }
13954                                                          else
13955                                                            {
13956                                                              /* 33222222222211111111110000000000
13957                                                                 10987654321098765432109876543210
13958                                                                 011001x1xx0x1000001xxxxxxxxxxxxx
13959                                                                 fadda.  */
13960                                                              return 1398;
13961                                                            }
13962                                                        }
13963                                                      else
13964                                                        {
13965                                                          /* 33222222222211111111110000000000
13966                                                             10987654321098765432109876543210
13967                                                             011001x1xx0xx100001xxxxxxxxxxxxx
13968                                                             fmaxnmv.  */
13969                                                          return 1445;
13970                                                        }
13971                                                    }
13972                                                  else
13973                                                    {
13974                                                      if (((word >> 18) & 0x1) == 0)
13975                                                        {
13976                                                          /* 33222222222211111111110000000000
13977                                                             10987654321098765432109876543210
13978                                                             011001x1xx0xx010001xxxxxxxxxxxxx
13979                                                             fcmeq.  */
13980                                                          return 1404;
13981                                                        }
13982                                                      else
13983                                                        {
13984                                                          if (((word >> 19) & 0x1) == 0)
13985                                                            {
13986                                                              /* 33222222222211111111110000000000
13987                                                                 10987654321098765432109876543210
13988                                                                 011001x1xx0x0110001xxxxxxxxxxxxx
13989                                                                 fmaxv.  */
13990                                                              return 1446;
13991                                                            }
13992                                                          else
13993                                                            {
13994                                                              /* 33222222222211111111110000000000
13995                                                                 10987654321098765432109876543210
13996                                                                 011001x1xx0x1110001xxxxxxxxxxxxx
13997                                                                 frecpe.  */
13998                                                              return 1474;
13999                                                            }
14000                                                        }
14001                                                    }
14002                                                }
14003                                              else
14004                                                {
14005                                                  if (((word >> 17) & 0x1) == 0)
14006                                                    {
14007                                                      if (((word >> 18) & 0x1) == 0)
14008                                                        {
14009                                                          if (((word >> 4) & 0x1) == 0)
14010                                                            {
14011                                                              /* 33222222222211111111110000000000
14012                                                                 10987654321098765432109876543210
14013                                                                 011001x1xx0xx001001xxxxxxxx0xxxx
14014                                                                 fcmlt.  */
14015                                                              return 1411;
14016                                                            }
14017                                                          else
14018                                                            {
14019                                                              /* 33222222222211111111110000000000
14020                                                                 10987654321098765432109876543210
14021                                                                 011001x1xx0xx001001xxxxxxxx1xxxx
14022                                                                 fcmle.  */
14023                                                              return 1410;
14024                                                            }
14025                                                        }
14026                                                      else
14027                                                        {
14028                                                          /* 33222222222211111111110000000000
14029                                                             10987654321098765432109876543210
14030                                                             011001x1xx0xx101001xxxxxxxxxxxxx
14031                                                             fminnmv.  */
14032                                                          return 1451;
14033                                                        }
14034                                                    }
14035                                                  else
14036                                                    {
14037                                                      if (((word >> 18) & 0x1) == 0)
14038                                                        {
14039                                                          /* 33222222222211111111110000000000
14040                                                             10987654321098765432109876543210
14041                                                             011001x1xx0xx011001xxxxxxxxxxxxx
14042                                                             fcmne.  */
14043                                                          return 1412;
14044                                                        }
14045                                                      else
14046                                                        {
14047                                                          if (((word >> 19) & 0x1) == 0)
14048                                                            {
14049                                                              /* 33222222222211111111110000000000
14050                                                                 10987654321098765432109876543210
14051                                                                 011001x1xx0x0111001xxxxxxxxxxxxx
14052                                                                 fminv.  */
14053                                                              return 1452;
14054                                                            }
14055                                                          else
14056                                                            {
14057                                                              /* 33222222222211111111110000000000
14058                                                                 10987654321098765432109876543210
14059                                                                 011001x1xx0x1111001xxxxxxxxxxxxx
14060                                                                 frsqrte.  */
14061                                                              return 1484;
14062                                                            }
14063                                                        }
14064                                                    }
14065                                                }
14066                                            }
14067                                          else
14068                                            {
14069                                              if (((word >> 22) & 0x1) == 0)
14070                                                {
14071                                                  if (((word >> 23) & 0x1) == 0)
14072                                                    {
14073                                                      /* 33222222222211111111110000000000
14074                                                         10987654321098765432109876543210
14075                                                         111001x1000xxxxx001xxxxxxxxxxxxx
14076                                                         stnt1w.  */
14077                                                      return 2260;
14078                                                    }
14079                                                  else
14080                                                    {
14081                                                      /* 33222222222211111111110000000000
14082                                                         10987654321098765432109876543210
14083                                                         111001x1100xxxxx001xxxxxxxxxxxxx
14084                                                         stnt1d.  */
14085                                                      return 2256;
14086                                                    }
14087                                                }
14088                                              else
14089                                                {
14090                                                  /* 33222222222211111111110000000000
14091                                                     10987654321098765432109876543210
14092                                                     111001x1x10xxxxx001xxxxxxxxxxxxx
14093                                                     stnt1w.  */
14094                                                  return 2259;
14095                                                }
14096                                            }
14097                                        }
14098                                    }
14099                                  else
14100                                    {
14101                                      if (((word >> 30) & 0x1) == 0)
14102                                        {
14103                                          if (((word >> 31) & 0x1) == 0)
14104                                            {
14105                                              if (((word >> 4) & 0x1) == 0)
14106                                                {
14107                                                  if (((word >> 12) & 0x1) == 0)
14108                                                    {
14109                                                      /* 33222222222211111111110000000000
14110                                                         10987654321098765432109876543210
14111                                                         001001x1xx1xxxxx0010xxxxxxx0xxxx
14112                                                         ctermeq.  */
14113                                                      return 1369;
14114                                                    }
14115                                                  else
14116                                                    {
14117                                                      /* 33222222222211111111110000000000
14118                                                         10987654321098765432109876543210
14119                                                         001001x1xx1xxxxx0011xxxxxxx0xxxx
14120                                                         whilewr.  */
14121                                                      return 2338;
14122                                                    }
14123                                                }
14124                                              else
14125                                                {
14126                                                  if (((word >> 12) & 0x1) == 0)
14127                                                    {
14128                                                      /* 33222222222211111111110000000000
14129                                                         10987654321098765432109876543210
14130                                                         001001x1xx1xxxxx0010xxxxxxx1xxxx
14131                                                         ctermne.  */
14132                                                      return 1370;
14133                                                    }
14134                                                  else
14135                                                    {
14136                                                      /* 33222222222211111111110000000000
14137                                                         10987654321098765432109876543210
14138                                                         001001x1xx1xxxxx0011xxxxxxx1xxxx
14139                                                         whilerw.  */
14140                                                      return 2337;
14141                                                    }
14142                                                }
14143                                            }
14144                                          else
14145                                            {
14146                                              if (((word >> 23) & 0x1) == 0)
14147                                                {
14148                                                  /* 33222222222211111111110000000000
14149                                                     10987654321098765432109876543210
14150                                                     101001x10x1xxxxx001xxxxxxxxxxxxx
14151                                                     ld1row.  */
14152                                                  return 2481;
14153                                                }
14154                                              else
14155                                                {
14156                                                  /* 33222222222211111111110000000000
14157                                                     10987654321098765432109876543210
14158                                                     101001x11x1xxxxx001xxxxxxxxxxxxx
14159                                                     ld1rod.  */
14160                                                  return 2482;
14161                                                }
14162                                            }
14163                                        }
14164                                      else
14165                                        {
14166                                          /* 33222222222211111111110000000000
14167                                             10987654321098765432109876543210
14168                                             x11001x1xx1xxxxx001xxxxxxxxxxxxx
14169                                             fmls.  */
14170                                          return 1457;
14171                                        }
14172                                    }
14173                                }
14174                            }
14175                          else
14176                            {
14177                              if (((word >> 30) & 0x1) == 0)
14178                                {
14179                                  if (((word >> 21) & 0x1) == 0)
14180                                    {
14181                                      if (((word >> 22) & 0x1) == 0)
14182                                        {
14183                                          if (((word >> 23) & 0x1) == 0)
14184                                            {
14185                                              if (((word >> 31) & 0x1) == 0)
14186                                                {
14187                                                  if (((word >> 9) & 0x1) == 0)
14188                                                    {
14189                                                      if (((word >> 20) & 0x1) == 0)
14190                                                        {
14191                                                          if (((word >> 4) & 0x1) == 0)
14192                                                            {
14193                                                              /* 33222222222211111111110000000000
14194                                                                 10987654321098765432109876543210
14195                                                                 001001x10000xxxx01xxxx0xxxx0xxxx
14196                                                                 and.  */
14197                                                              return 1300;
14198                                                            }
14199                                                          else
14200                                                            {
14201                                                              /* 33222222222211111111110000000000
14202                                                                 10987654321098765432109876543210
14203                                                                 001001x10000xxxx01xxxx0xxxx1xxxx
14204                                                                 bic.  */
14205                                                              return 1312;
14206                                                            }
14207                                                        }
14208                                                      else
14209                                                        {
14210                                                          if (((word >> 19) & 0x1) == 0)
14211                                                            {
14212                                                              /* 33222222222211111111110000000000
14213                                                                 10987654321098765432109876543210
14214                                                                 001001x100010xxx01xxxx0xxxxxxxxx
14215                                                                 brka.  */
14216                                                              return 1314;
14217                                                            }
14218                                                          else
14219                                                            {
14220                                                              /* 33222222222211111111110000000000
14221                                                                 10987654321098765432109876543210
14222                                                                 001001x100011xxx01xxxx0xxxxxxxxx
14223                                                                 brkn.  */
14224                                                              return 1318;
14225                                                            }
14226                                                        }
14227                                                    }
14228                                                  else
14229                                                    {
14230                                                      if (((word >> 4) & 0x1) == 0)
14231                                                        {
14232                                                          /* 33222222222211111111110000000000
14233                                                             10987654321098765432109876543210
14234                                                             001001x1000xxxxx01xxxx1xxxx0xxxx
14235                                                             eor.  */
14236                                                          return 1387;
14237                                                        }
14238                                                      else
14239                                                        {
14240                                                          /* 33222222222211111111110000000000
14241                                                             10987654321098765432109876543210
14242                                                             001001x1000xxxxx01xxxx1xxxx1xxxx
14243                                                             sel.  */
14244                                                          return 1836;
14245                                                        }
14246                                                    }
14247                                                }
14248                                              else
14249                                                {
14250                                                  if (((word >> 13) & 0x1) == 0)
14251                                                    {
14252                                                      /* 33222222222211111111110000000000
14253                                                         10987654321098765432109876543210
14254                                                         101001x1000xxxxx010xxxxxxxxxxxxx
14255                                                         ld1sh.  */
14256                                                      return 1586;
14257                                                    }
14258                                                  else
14259                                                    {
14260                                                      /* 33222222222211111111110000000000
14261                                                         10987654321098765432109876543210
14262                                                         101001x1000xxxxx011xxxxxxxxxxxxx
14263                                                         ldff1sh.  */
14264                                                      return 1686;
14265                                                    }
14266                                                }
14267                                            }
14268                                          else
14269                                            {
14270                                              if (((word >> 31) & 0x1) == 0)
14271                                                {
14272                                                  if (((word >> 9) & 0x1) == 0)
14273                                                    {
14274                                                      if (((word >> 20) & 0x1) == 0)
14275                                                        {
14276                                                          if (((word >> 4) & 0x1) == 0)
14277                                                            {
14278                                                              /* 33222222222211111111110000000000
14279                                                                 10987654321098765432109876543210
14280                                                                 001001x11000xxxx01xxxx0xxxx0xxxx
14281                                                                 orr.  */
14282                                                              return 1772;
14283                                                            }
14284                                                          else
14285                                                            {
14286                                                              /* 33222222222211111111110000000000
14287                                                                 10987654321098765432109876543210
14288                                                                 001001x11000xxxx01xxxx0xxxx1xxxx
14289                                                                 orn.  */
14290                                                              return 1767;
14291                                                            }
14292                                                        }
14293                                                      else
14294                                                        {
14295                                                          /* 33222222222211111111110000000000
14296                                                             10987654321098765432109876543210
14297                                                             001001x11001xxxx01xxxx0xxxxxxxxx
14298                                                             brkb.  */
14299                                                          return 1316;
14300                                                        }
14301                                                    }
14302                                                  else
14303                                                    {
14304                                                      if (((word >> 4) & 0x1) == 0)
14305                                                        {
14306                                                          /* 33222222222211111111110000000000
14307                                                             10987654321098765432109876543210
14308                                                             001001x1100xxxxx01xxxx1xxxx0xxxx
14309                                                             nor.  */
14310                                                          return 1764;
14311                                                        }
14312                                                      else
14313                                                        {
14314                                                          /* 33222222222211111111110000000000
14315                                                             10987654321098765432109876543210
14316                                                             001001x1100xxxxx01xxxx1xxxx1xxxx
14317                                                             nand.  */
14318                                                          return 1761;
14319                                                        }
14320                                                    }
14321                                                }
14322                                              else
14323                                                {
14324                                                  if (((word >> 13) & 0x1) == 0)
14325                                                    {
14326                                                      /* 33222222222211111111110000000000
14327                                                         10987654321098765432109876543210
14328                                                         101001x1100xxxxx010xxxxxxxxxxxxx
14329                                                         ld1sb.  */
14330                                                      return 1574;
14331                                                    }
14332                                                  else
14333                                                    {
14334                                                      /* 33222222222211111111110000000000
14335                                                         10987654321098765432109876543210
14336                                                         101001x1100xxxxx011xxxxxxxxxxxxx
14337                                                         ldff1sb.  */
14338                                                      return 1674;
14339                                                    }
14340                                                }
14341                                            }
14342                                        }
14343                                      else
14344                                        {
14345                                          if (((word >> 23) & 0x1) == 0)
14346                                            {
14347                                              if (((word >> 31) & 0x1) == 0)
14348                                                {
14349                                                  if (((word >> 4) & 0x1) == 0)
14350                                                    {
14351                                                      if (((word >> 9) & 0x1) == 0)
14352                                                        {
14353                                                          if (((word >> 20) & 0x1) == 0)
14354                                                            {
14355                                                              /* 33222222222211111111110000000000
14356                                                                 10987654321098765432109876543210
14357                                                                 001001x10100xxxx01xxxx0xxxx0xxxx
14358                                                                 ands.  */
14359                                                              return 1301;
14360                                                            }
14361                                                          else
14362                                                            {
14363                                                              if (((word >> 19) & 0x1) == 0)
14364                                                                {
14365                                                                  /* 33222222222211111111110000000000
14366                                                                     10987654321098765432109876543210
14367                                                                     001001x101010xxx01xxxx0xxxx0xxxx
14368                                                                     brkas.  */
14369                                                                  return 1315;
14370                                                                }
14371                                                              else
14372                                                                {
14373                                                                  /* 33222222222211111111110000000000
14374                                                                     10987654321098765432109876543210
14375                                                                     001001x101011xxx01xxxx0xxxx0xxxx
14376                                                                     brkns.  */
14377                                                                  return 1319;
14378                                                                }
14379                                                            }
14380                                                        }
14381                                                      else
14382                                                        {
14383                                                          /* 33222222222211111111110000000000
14384                                                             10987654321098765432109876543210
14385                                                             001001x1010xxxxx01xxxx1xxxx0xxxx
14386                                                             eors.  */
14387                                                          return 1388;
14388                                                        }
14389                                                    }
14390                                                  else
14391                                                    {
14392                                                      /* 33222222222211111111110000000000
14393                                                         10987654321098765432109876543210
14394                                                         001001x1010xxxxx01xxxxxxxxx1xxxx
14395                                                         bics.  */
14396                                                      return 1313;
14397                                                    }
14398                                                }
14399                                              else
14400                                                {
14401                                                  if (((word >> 13) & 0x1) == 0)
14402                                                    {
14403                                                      /* 33222222222211111111110000000000
14404                                                         10987654321098765432109876543210
14405                                                         101001x1010xxxxx010xxxxxxxxxxxxx
14406                                                         ld1w.  */
14407                                                      return 1605;
14408                                                    }
14409                                                  else
14410                                                    {
14411                                                      /* 33222222222211111111110000000000
14412                                                         10987654321098765432109876543210
14413                                                         101001x1010xxxxx011xxxxxxxxxxxxx
14414                                                         ldff1w.  */
14415                                                      return 1705;
14416                                                    }
14417                                                }
14418                                            }
14419                                          else
14420                                            {
14421                                              if (((word >> 31) & 0x1) == 0)
14422                                                {
14423                                                  if (((word >> 4) & 0x1) == 0)
14424                                                    {
14425                                                      if (((word >> 9) & 0x1) == 0)
14426                                                        {
14427                                                          if (((word >> 20) & 0x1) == 0)
14428                                                            {
14429                                                              /* 33222222222211111111110000000000
14430                                                                 10987654321098765432109876543210
14431                                                                 001001x11100xxxx01xxxx0xxxx0xxxx
14432                                                                 orrs.  */
14433                                                              return 1773;
14434                                                            }
14435                                                          else
14436                                                            {
14437                                                              /* 33222222222211111111110000000000
14438                                                                 10987654321098765432109876543210
14439                                                                 001001x11101xxxx01xxxx0xxxx0xxxx
14440                                                                 brkbs.  */
14441                                                              return 1317;
14442                                                            }
14443                                                        }
14444                                                      else
14445                                                        {
14446                                                          /* 33222222222211111111110000000000
14447                                                             10987654321098765432109876543210
14448                                                             001001x1110xxxxx01xxxx1xxxx0xxxx
14449                                                             nors.  */
14450                                                          return 1765;
14451                                                        }
14452                                                    }
14453                                                  else
14454                                                    {
14455                                                      if (((word >> 9) & 0x1) == 0)
14456                                                        {
14457                                                          /* 33222222222211111111110000000000
14458                                                             10987654321098765432109876543210
14459                                                             001001x1110xxxxx01xxxx0xxxx1xxxx
14460                                                             orns.  */
14461                                                          return 1768;
14462                                                        }
14463                                                      else
14464                                                        {
14465                                                          /* 33222222222211111111110000000000
14466                                                             10987654321098765432109876543210
14467                                                             001001x1110xxxxx01xxxx1xxxx1xxxx
14468                                                             nands.  */
14469                                                          return 1762;
14470                                                        }
14471                                                    }
14472                                                }
14473                                              else
14474                                                {
14475                                                  if (((word >> 13) & 0x1) == 0)
14476                                                    {
14477                                                      /* 33222222222211111111110000000000
14478                                                         10987654321098765432109876543210
14479                                                         101001x1110xxxxx010xxxxxxxxxxxxx
14480                                                         ld1sb.  */
14481                                                      return 1576;
14482                                                    }
14483                                                  else
14484                                                    {
14485                                                      /* 33222222222211111111110000000000
14486                                                         10987654321098765432109876543210
14487                                                         101001x1110xxxxx011xxxxxxxxxxxxx
14488                                                         ldff1sb.  */
14489                                                      return 1678;
14490                                                    }
14491                                                }
14492                                            }
14493                                        }
14494                                    }
14495                                  else
14496                                    {
14497                                      if (((word >> 31) & 0x1) == 0)
14498                                        {
14499                                          /* 33222222222211111111110000000000
14500                                             10987654321098765432109876543210
14501                                             001001x1xx1xxxxx01xxxxxxxxxxxxxx
14502                                             psel.  */
14503                                          return 2413;
14504                                        }
14505                                      else
14506                                        {
14507                                          if (((word >> 13) & 0x1) == 0)
14508                                            {
14509                                              if (((word >> 22) & 0x1) == 0)
14510                                                {
14511                                                  if (((word >> 23) & 0x1) == 0)
14512                                                    {
14513                                                      /* 33222222222211111111110000000000
14514                                                         10987654321098765432109876543210
14515                                                         101001x1001xxxxx010xxxxxxxxxxxxx
14516                                                         ld1sh.  */
14517                                                      return 1587;
14518                                                    }
14519                                                  else
14520                                                    {
14521                                                      /* 33222222222211111111110000000000
14522                                                         10987654321098765432109876543210
14523                                                         101001x1101xxxxx010xxxxxxxxxxxxx
14524                                                         ld1sb.  */
14525                                                      return 1575;
14526                                                    }
14527                                                }
14528                                              else
14529                                                {
14530                                                  if (((word >> 23) & 0x1) == 0)
14531                                                    {
14532                                                      /* 33222222222211111111110000000000
14533                                                         10987654321098765432109876543210
14534                                                         101001x1011xxxxx010xxxxxxxxxxxxx
14535                                                         ld1w.  */
14536                                                      return 1606;
14537                                                    }
14538                                                  else
14539                                                    {
14540                                                      /* 33222222222211111111110000000000
14541                                                         10987654321098765432109876543210
14542                                                         101001x1111xxxxx010xxxxxxxxxxxxx
14543                                                         ld1d.  */
14544                                                      return 1528;
14545                                                    }
14546                                                }
14547                                            }
14548                                          else
14549                                            {
14550                                              if (((word >> 22) & 0x1) == 0)
14551                                                {
14552                                                  if (((word >> 23) & 0x1) == 0)
14553                                                    {
14554                                                      /* 33222222222211111111110000000000
14555                                                         10987654321098765432109876543210
14556                                                         101001x1001xxxxx011xxxxxxxxxxxxx
14557                                                         ldff1sh.  */
14558                                                      return 1688;
14559                                                    }
14560                                                  else
14561                                                    {
14562                                                      /* 33222222222211111111110000000000
14563                                                         10987654321098765432109876543210
14564                                                         101001x1101xxxxx011xxxxxxxxxxxxx
14565                                                         ldff1sb.  */
14566                                                      return 1676;
14567                                                    }
14568                                                }
14569                                              else
14570                                                {
14571                                                  if (((word >> 23) & 0x1) == 0)
14572                                                    {
14573                                                      /* 33222222222211111111110000000000
14574                                                         10987654321098765432109876543210
14575                                                         101001x1011xxxxx011xxxxxxxxxxxxx
14576                                                         ldff1w.  */
14577                                                      return 1707;
14578                                                    }
14579                                                  else
14580                                                    {
14581                                                      /* 33222222222211111111110000000000
14582                                                         10987654321098765432109876543210
14583                                                         101001x1111xxxxx011xxxxxxxxxxxxx
14584                                                         ldff1d.  */
14585                                                      return 1652;
14586                                                    }
14587                                                }
14588                                            }
14589                                        }
14590                                    }
14591                                }
14592                              else
14593                                {
14594                                  if (((word >> 13) & 0x1) == 0)
14595                                    {
14596                                      if (((word >> 31) & 0x1) == 0)
14597                                        {
14598                                          if (((word >> 21) & 0x1) == 0)
14599                                            {
14600                                              if (((word >> 4) & 0x1) == 0)
14601                                                {
14602                                                  /* 33222222222211111111110000000000
14603                                                     10987654321098765432109876543210
14604                                                     011001x1xx0xxxxx010xxxxxxxx0xxxx
14605                                                     fcmge.  */
14606                                                  return 1407;
14607                                                }
14608                                              else
14609                                                {
14610                                                  /* 33222222222211111111110000000000
14611                                                     10987654321098765432109876543210
14612                                                     011001x1xx0xxxxx010xxxxxxxx1xxxx
14613                                                     fcmgt.  */
14614                                                  return 1409;
14615                                                }
14616                                            }
14617                                          else
14618                                            {
14619                                              /* 33222222222211111111110000000000
14620                                                 10987654321098765432109876543210
14621                                                 011001x1xx1xxxxx010xxxxxxxxxxxxx
14622                                                 fnmla.  */
14623                                              return 1471;
14624                                            }
14625                                        }
14626                                      else
14627                                        {
14628                                          if (((word >> 22) & 0x1) == 0)
14629                                            {
14630                                              /* 33222222222211111111110000000000
14631                                                 10987654321098765432109876543210
14632                                                 111001x1x0xxxxxx010xxxxxxxxxxxxx
14633                                                 str.  */
14634                                              return 1957;
14635                                            }
14636                                          else
14637                                            {
14638                                              if (((word >> 21) & 0x1) == 0)
14639                                                {
14640                                                  /* 33222222222211111111110000000000
14641                                                     10987654321098765432109876543210
14642                                                     111001x1x10xxxxx010xxxxxxxxxxxxx
14643                                                     st1w.  */
14644                                                  return 1916;
14645                                                }
14646                                              else
14647                                                {
14648                                                  if (((word >> 23) & 0x1) == 0)
14649                                                    {
14650                                                      /* 33222222222211111111110000000000
14651                                                         10987654321098765432109876543210
14652                                                         111001x1011xxxxx010xxxxxxxxxxxxx
14653                                                         st1w.  */
14654                                                      return 1918;
14655                                                    }
14656                                                  else
14657                                                    {
14658                                                      /* 33222222222211111111110000000000
14659                                                         10987654321098765432109876543210
14660                                                         111001x1111xxxxx010xxxxxxxxxxxxx
14661                                                         st1d.  */
14662                                                      return 1895;
14663                                                    }
14664                                                }
14665                                            }
14666                                        }
14667                                    }
14668                                  else
14669                                    {
14670                                      if (((word >> 21) & 0x1) == 0)
14671                                        {
14672                                          if (((word >> 31) & 0x1) == 0)
14673                                            {
14674                                              if (((word >> 4) & 0x1) == 0)
14675                                                {
14676                                                  /* 33222222222211111111110000000000
14677                                                     10987654321098765432109876543210
14678                                                     011001x1xx0xxxxx011xxxxxxxx0xxxx
14679                                                     fcmeq.  */
14680                                                  return 1405;
14681                                                }
14682                                              else
14683                                                {
14684                                                  /* 33222222222211111111110000000000
14685                                                     10987654321098765432109876543210
14686                                                     011001x1xx0xxxxx011xxxxxxxx1xxxx
14687                                                     fcmne.  */
14688                                                  return 1413;
14689                                                }
14690                                            }
14691                                          else
14692                                            {
14693                                              if (((word >> 22) & 0x1) == 0)
14694                                                {
14695                                                  if (((word >> 23) & 0x1) == 0)
14696                                                    {
14697                                                      /* 33222222222211111111110000000000
14698                                                         10987654321098765432109876543210
14699                                                         111001x1000xxxxx011xxxxxxxxxxxxx
14700                                                         stnt1w.  */
14701                                                      return 1954;
14702                                                    }
14703                                                  else
14704                                                    {
14705                                                      /* 33222222222211111111110000000000
14706                                                         10987654321098765432109876543210
14707                                                         111001x1100xxxxx011xxxxxxxxxxxxx
14708                                                         stnt1d.  */
14709                                                      return 1950;
14710                                                    }
14711                                                }
14712                                              else
14713                                                {
14714                                                  if (((word >> 23) & 0x1) == 0)
14715                                                    {
14716                                                      /* 33222222222211111111110000000000
14717                                                         10987654321098765432109876543210
14718                                                         111001x1010xxxxx011xxxxxxxxxxxxx
14719                                                         st3w.  */
14720                                                      return 1938;
14721                                                    }
14722                                                  else
14723                                                    {
14724                                                      /* 33222222222211111111110000000000
14725                                                         10987654321098765432109876543210
14726                                                         111001x1110xxxxx011xxxxxxxxxxxxx
14727                                                         st3d.  */
14728                                                      return 1934;
14729                                                    }
14730                                                }
14731                                            }
14732                                        }
14733                                      else
14734                                        {
14735                                          if (((word >> 31) & 0x1) == 0)
14736                                            {
14737                                              /* 33222222222211111111110000000000
14738                                                 10987654321098765432109876543210
14739                                                 011001x1xx1xxxxx011xxxxxxxxxxxxx
14740                                                 fnmls.  */
14741                                              return 1472;
14742                                            }
14743                                          else
14744                                            {
14745                                              if (((word >> 22) & 0x1) == 0)
14746                                                {
14747                                                  if (((word >> 23) & 0x1) == 0)
14748                                                    {
14749                                                      /* 33222222222211111111110000000000
14750                                                         10987654321098765432109876543210
14751                                                         111001x1001xxxxx011xxxxxxxxxxxxx
14752                                                         st2w.  */
14753                                                      return 1930;
14754                                                    }
14755                                                  else
14756                                                    {
14757                                                      /* 33222222222211111111110000000000
14758                                                         10987654321098765432109876543210
14759                                                         111001x1101xxxxx011xxxxxxxxxxxxx
14760                                                         st2d.  */
14761                                                      return 1926;
14762                                                    }
14763                                                }
14764                                              else
14765                                                {
14766                                                  if (((word >> 23) & 0x1) == 0)
14767                                                    {
14768                                                      /* 33222222222211111111110000000000
14769                                                         10987654321098765432109876543210
14770                                                         111001x1011xxxxx011xxxxxxxxxxxxx
14771                                                         st4w.  */
14772                                                      return 1946;
14773                                                    }
14774                                                  else
14775                                                    {
14776                                                      /* 33222222222211111111110000000000
14777                                                         10987654321098765432109876543210
14778                                                         111001x1111xxxxx011xxxxxxxxxxxxx
14779                                                         st4d.  */
14780                                                      return 1942;
14781                                                    }
14782                                                }
14783                                            }
14784                                        }
14785                                    }
14786                                }
14787                            }
14788                        }
14789                      else
14790                        {
14791                          if (((word >> 21) & 0x1) == 0)
14792                            {
14793                              if (((word >> 30) & 0x1) == 0)
14794                                {
14795                                  if (((word >> 14) & 0x1) == 0)
14796                                    {
14797                                      if (((word >> 13) & 0x1) == 0)
14798                                        {
14799                                          if (((word >> 4) & 0x1) == 0)
14800                                            {
14801                                              /* 33222222222211111111110000000000
14802                                                 10987654321098765432109876543210
14803                                                 x01001x1xx0xxxxx100xxxxxxxx0xxxx
14804                                                 cmpeq.  */
14805                                              return 1334;
14806                                            }
14807                                          else
14808                                            {
14809                                              /* 33222222222211111111110000000000
14810                                                 10987654321098765432109876543210
14811                                                 x01001x1xx0xxxxx100xxxxxxxx1xxxx
14812                                                 cmpne.  */
14813                                              return 1357;
14814                                            }
14815                                        }
14816                                      else
14817                                        {
14818                                          if (((word >> 20) & 0x1) == 0)
14819                                            {
14820                                              if (((word >> 22) & 0x1) == 0)
14821                                                {
14822                                                  if (((word >> 23) & 0x1) == 0)
14823                                                    {
14824                                                      /* 33222222222211111111110000000000
14825                                                         10987654321098765432109876543210
14826                                                         x01001x10000xxxx101xxxxxxxxxxxxx
14827                                                         ld1sh.  */
14828                                                      return 1593;
14829                                                    }
14830                                                  else
14831                                                    {
14832                                                      /* 33222222222211111111110000000000
14833                                                         10987654321098765432109876543210
14834                                                         x01001x11000xxxx101xxxxxxxxxxxxx
14835                                                         ld1sb.  */
14836                                                      return 1580;
14837                                                    }
14838                                                }
14839                                              else
14840                                                {
14841                                                  if (((word >> 23) & 0x1) == 0)
14842                                                    {
14843                                                      /* 33222222222211111111110000000000
14844                                                         10987654321098765432109876543210
14845                                                         x01001x10100xxxx101xxxxxxxxxxxxx
14846                                                         ld1w.  */
14847                                                      return 1612;
14848                                                    }
14849                                                  else
14850                                                    {
14851                                                      /* 33222222222211111111110000000000
14852                                                         10987654321098765432109876543210
14853                                                         x01001x11100xxxx101xxxxxxxxxxxxx
14854                                                         ld1sb.  */
14855                                                      return 1582;
14856                                                    }
14857                                                }
14858                                            }
14859                                          else
14860                                            {
14861                                              if (((word >> 22) & 0x1) == 0)
14862                                                {
14863                                                  if (((word >> 23) & 0x1) == 0)
14864                                                    {
14865                                                      /* 33222222222211111111110000000000
14866                                                         10987654321098765432109876543210
14867                                                         x01001x10001xxxx101xxxxxxxxxxxxx
14868                                                         ldnf1sh.  */
14869                                                      return 1726;
14870                                                    }
14871                                                  else
14872                                                    {
14873                                                      /* 33222222222211111111110000000000
14874                                                         10987654321098765432109876543210
14875                                                         x01001x11001xxxx101xxxxxxxxxxxxx
14876                                                         ldnf1sb.  */
14877                                                      return 1723;
14878                                                    }
14879                                                }
14880                                              else
14881                                                {
14882                                                  if (((word >> 23) & 0x1) == 0)
14883                                                    {
14884                                                      /* 33222222222211111111110000000000
14885                                                         10987654321098765432109876543210
14886                                                         x01001x10101xxxx101xxxxxxxxxxxxx
14887                                                         ldnf1w.  */
14888                                                      return 1729;
14889                                                    }
14890                                                  else
14891                                                    {
14892                                                      /* 33222222222211111111110000000000
14893                                                         10987654321098765432109876543210
14894                                                         x01001x11101xxxx101xxxxxxxxxxxxx
14895                                                         ldnf1sb.  */
14896                                                      return 1725;
14897                                                    }
14898                                                }
14899                                            }
14900                                        }
14901                                    }
14902                                  else
14903                                    {
14904                                      if (((word >> 31) & 0x1) == 0)
14905                                        {
14906                                          if (((word >> 4) & 0x1) == 0)
14907                                            {
14908                                              if (((word >> 20) & 0x1) == 0)
14909                                                {
14910                                                  if (((word >> 22) & 0x1) == 0)
14911                                                    {
14912                                                      /* 33222222222211111111110000000000
14913                                                         10987654321098765432109876543210
14914                                                         001001x1x000xxxx11xxxxxxxxx0xxxx
14915                                                         brkpa.  */
14916                                                      return 1320;
14917                                                    }
14918                                                  else
14919                                                    {
14920                                                      /* 33222222222211111111110000000000
14921                                                         10987654321098765432109876543210
14922                                                         001001x1x100xxxx11xxxxxxxxx0xxxx
14923                                                         brkpas.  */
14924                                                      return 1321;
14925                                                    }
14926                                                }
14927                                              else
14928                                                {
14929                                                  if (((word >> 16) & 0x1) == 0)
14930                                                    {
14931                                                      if (((word >> 19) & 0x1) == 0)
14932                                                        {
14933                                                          /* 33222222222211111111110000000000
14934                                                             10987654321098765432109876543210
14935                                                             001001x1xx010xx011xxxxxxxxx0xxxx
14936                                                             ptest.  */
14937                                                          return 1806;
14938                                                        }
14939                                                      else
14940                                                        {
14941                                                          if (((word >> 10) & 0x1) == 0)
14942                                                            {
14943                                                              if (((word >> 12) & 0x1) == 0)
14944                                                                {
14945                                                                  if (((word >> 13) & 0x1) == 0)
14946                                                                    {
14947                                                                      /* 33222222222211111111110000000000
14948                                                                         10987654321098765432109876543210
14949                                                                         001001x1xx011xx01100x0xxxxx0xxxx
14950                                                                         pfirst.  */
14951                                                                      return 1776;
14952                                                                    }
14953                                                                  else
14954                                                                    {
14955                                                                      /* 33222222222211111111110000000000
14956                                                                         10987654321098765432109876543210
14957                                                                         001001x1xx011xx01110x0xxxxx0xxxx
14958                                                                         ptrue.  */
14959                                                                      return 1807;
14960                                                                    }
14961                                                                }
14962                                                              else
14963                                                                {
14964                                                                  if (((word >> 22) & 0x1) == 0)
14965                                                                    {
14966                                                                      /* 33222222222211111111110000000000
14967                                                                         10987654321098765432109876543210
14968                                                                         001001x1x0011xx011x1x0xxxxx0xxxx
14969                                                                         rdffr.  */
14970                                                                      return 1813;
14971                                                                    }
14972                                                                  else
14973                                                                    {
14974                                                                      /* 33222222222211111111110000000000
14975                                                                         10987654321098765432109876543210
14976                                                                         001001x1x1011xx011x1x0xxxxx0xxxx
14977                                                                         rdffrs.  */
14978                                                                      return 1814;
14979                                                                    }
14980                                                                }
14981                                                            }
14982                                                          else
14983                                                            {
14984                                                              /* 33222222222211111111110000000000
14985                                                                 10987654321098765432109876543210
14986                                                                 001001x1xx011xx011xxx1xxxxx0xxxx
14987                                                                 pfalse.  */
14988                                                              return 1775;
14989                                                            }
14990                                                        }
14991                                                    }
14992                                                  else
14993                                                    {
14994                                                      if (((word >> 10) & 0x1) == 0)
14995                                                        {
14996                                                          if (((word >> 12) & 0x1) == 0)
14997                                                            {
14998                                                              /* 33222222222211111111110000000000
14999                                                                 10987654321098765432109876543210
15000                                                                 001001x1xx01xxx111x0x0xxxxx0xxxx
15001                                                                 ptrues.  */
15002                                                              return 1808;
15003                                                            }
15004                                                          else
15005                                                            {
15006                                                              /* 33222222222211111111110000000000
15007                                                                 10987654321098765432109876543210
15008                                                                 001001x1xx01xxx111x1x0xxxxx0xxxx
15009                                                                 rdffr.  */
15010                                                              return 1812;
15011                                                            }
15012                                                        }
15013                                                      else
15014                                                        {
15015                                                          /* 33222222222211111111110000000000
15016                                                             10987654321098765432109876543210
15017                                                             001001x1xx01xxx111xxx1xxxxx0xxxx
15018                                                             pnext.  */
15019                                                          return 1777;
15020                                                        }
15021                                                    }
15022                                                }
15023                                            }
15024                                          else
15025                                            {
15026                                              if (((word >> 22) & 0x1) == 0)
15027                                                {
15028                                                  /* 33222222222211111111110000000000
15029                                                     10987654321098765432109876543210
15030                                                     001001x1x00xxxxx11xxxxxxxxx1xxxx
15031                                                     brkpb.  */
15032                                                  return 1322;
15033                                                }
15034                                              else
15035                                                {
15036                                                  /* 33222222222211111111110000000000
15037                                                     10987654321098765432109876543210
15038                                                     001001x1x10xxxxx11xxxxxxxxx1xxxx
15039                                                     brkpbs.  */
15040                                                  return 1323;
15041                                                }
15042                                            }
15043                                        }
15044                                      else
15045                                        {
15046                                          if (((word >> 13) & 0x1) == 0)
15047                                            {
15048                                              if (((word >> 22) & 0x1) == 0)
15049                                                {
15050                                                  if (((word >> 23) & 0x1) == 0)
15051                                                    {
15052                                                      /* 33222222222211111111110000000000
15053                                                         10987654321098765432109876543210
15054                                                         101001x1000xxxxx110xxxxxxxxxxxxx
15055                                                         ldnt1w.  */
15056                                                      return 1737;
15057                                                    }
15058                                                  else
15059                                                    {
15060                                                      /* 33222222222211111111110000000000
15061                                                         10987654321098765432109876543210
15062                                                         101001x1100xxxxx110xxxxxxxxxxxxx
15063                                                         ldnt1d.  */
15064                                                      return 1733;
15065                                                    }
15066                                                }
15067                                              else
15068                                                {
15069                                                  if (((word >> 23) & 0x1) == 0)
15070                                                    {
15071                                                      /* 33222222222211111111110000000000
15072                                                         10987654321098765432109876543210
15073                                                         101001x1010xxxxx110xxxxxxxxxxxxx
15074                                                         ld3w.  */
15075                                                      return 1629;
15076                                                    }
15077                                                  else
15078                                                    {
15079                                                      /* 33222222222211111111110000000000
15080                                                         10987654321098765432109876543210
15081                                                         101001x1110xxxxx110xxxxxxxxxxxxx
15082                                                         ld3d.  */
15083                                                      return 1625;
15084                                                    }
15085                                                }
15086                                            }
15087                                          else
15088                                            {
15089                                              if (((word >> 22) & 0x1) == 0)
15090                                                {
15091                                                  if (((word >> 23) & 0x1) == 0)
15092                                                    {
15093                                                      /* 33222222222211111111110000000000
15094                                                         10987654321098765432109876543210
15095                                                         101001x1000xxxxx111xxxxxxxxxxxxx
15096                                                         ldnt1w.  */
15097                                                      return 1738;
15098                                                    }
15099                                                  else
15100                                                    {
15101                                                      /* 33222222222211111111110000000000
15102                                                         10987654321098765432109876543210
15103                                                         101001x1100xxxxx111xxxxxxxxxxxxx
15104                                                         ldnt1d.  */
15105                                                      return 1734;
15106                                                    }
15107                                                }
15108                                              else
15109                                                {
15110                                                  if (((word >> 23) & 0x1) == 0)
15111                                                    {
15112                                                      /* 33222222222211111111110000000000
15113                                                         10987654321098765432109876543210
15114                                                         101001x1010xxxxx111xxxxxxxxxxxxx
15115                                                         ld3w.  */
15116                                                      return 1630;
15117                                                    }
15118                                                  else
15119                                                    {
15120                                                      /* 33222222222211111111110000000000
15121                                                         10987654321098765432109876543210
15122                                                         101001x1110xxxxx111xxxxxxxxxxxxx
15123                                                         ld3d.  */
15124                                                      return 1626;
15125                                                    }
15126                                                }
15127                                            }
15128                                        }
15129                                    }
15130                                }
15131                              else
15132                                {
15133                                  if (((word >> 13) & 0x1) == 0)
15134                                    {
15135                                      if (((word >> 31) & 0x1) == 0)
15136                                        {
15137                                          if (((word >> 14) & 0x1) == 0)
15138                                            {
15139                                              if (((word >> 19) & 0x1) == 0)
15140                                                {
15141                                                  if (((word >> 20) & 0x1) == 0)
15142                                                    {
15143                                                      if (((word >> 16) & 0x1) == 0)
15144                                                        {
15145                                                          if (((word >> 17) & 0x1) == 0)
15146                                                            {
15147                                                              if (((word >> 18) & 0x1) == 0)
15148                                                                {
15149                                                                  /* 33222222222211111111110000000000
15150                                                                     10987654321098765432109876543210
15151                                                                     011001x1xx000000100xxxxxxxxxxxxx
15152                                                                     fadd.  */
15153                                                                  return 1396;
15154                                                                }
15155                                                              else
15156                                                                {
15157                                                                  /* 33222222222211111111110000000000
15158                                                                     10987654321098765432109876543210
15159                                                                     011001x1xx000100100xxxxxxxxxxxxx
15160                                                                     fmaxnm.  */
15161                                                                  return 1443;
15162                                                                }
15163                                                            }
15164                                                          else
15165                                                            {
15166                                                              if (((word >> 18) & 0x1) == 0)
15167                                                                {
15168                                                                  /* 33222222222211111111110000000000
15169                                                                     10987654321098765432109876543210
15170                                                                     011001x1xx000010100xxxxxxxxxxxxx
15171                                                                     fmul.  */
15172                                                                  return 1463;
15173                                                                }
15174                                                              else
15175                                                                {
15176                                                                  /* 33222222222211111111110000000000
15177                                                                     10987654321098765432109876543210
15178                                                                     011001x1xx000110100xxxxxxxxxxxxx
15179                                                                     fmax.  */
15180                                                                  return 1441;
15181                                                                }
15182                                                            }
15183                                                        }
15184                                                      else
15185                                                        {
15186                                                          if (((word >> 17) & 0x1) == 0)
15187                                                            {
15188                                                              if (((word >> 18) & 0x1) == 0)
15189                                                                {
15190                                                                  /* 33222222222211111111110000000000
15191                                                                     10987654321098765432109876543210
15192                                                                     011001x1xx000001100xxxxxxxxxxxxx
15193                                                                     fsub.  */
15194                                                                  return 1489;
15195                                                                }
15196                                                              else
15197                                                                {
15198                                                                  /* 33222222222211111111110000000000
15199                                                                     10987654321098765432109876543210
15200                                                                     011001x1xx000101100xxxxxxxxxxxxx
15201                                                                     fminnm.  */
15202                                                                  return 1449;
15203                                                                }
15204                                                            }
15205                                                          else
15206                                                            {
15207                                                              if (((word >> 18) & 0x1) == 0)
15208                                                                {
15209                                                                  /* 33222222222211111111110000000000
15210                                                                     10987654321098765432109876543210
15211                                                                     011001x1xx000011100xxxxxxxxxxxxx
15212                                                                     fsubr.  */
15213                                                                  return 1491;
15214                                                                }
15215                                                              else
15216                                                                {
15217                                                                  /* 33222222222211111111110000000000
15218                                                                     10987654321098765432109876543210
15219                                                                     011001x1xx000111100xxxxxxxxxxxxx
15220                                                                     fmin.  */
15221                                                                  return 1447;
15222                                                                }
15223                                                            }
15224                                                        }
15225                                                    }
15226                                                  else
15227                                                    {
15228                                                      /* 33222222222211111111110000000000
15229                                                         10987654321098765432109876543210
15230                                                         011001x1xx010xxx100xxxxxxxxxxxxx
15231                                                         ftmad.  */
15232                                                      return 1493;
15233                                                    }
15234                                                }
15235                                              else
15236                                                {
15237                                                  if (((word >> 16) & 0x1) == 0)
15238                                                    {
15239                                                      if (((word >> 17) & 0x1) == 0)
15240                                                        {
15241                                                          if (((word >> 18) & 0x1) == 0)
15242                                                            {
15243                                                              if (((word >> 20) & 0x1) == 0)
15244                                                                {
15245                                                                  /* 33222222222211111111110000000000
15246                                                                     10987654321098765432109876543210
15247                                                                     011001x1xx001000100xxxxxxxxxxxxx
15248                                                                     fabd.  */
15249                                                                  return 1391;
15250                                                                }
15251                                                              else
15252                                                                {
15253                                                                  /* 33222222222211111111110000000000
15254                                                                     10987654321098765432109876543210
15255                                                                     011001x1xx011000100xxxxxxxxxxxxx
15256                                                                     fadd.  */
15257                                                                  return 1397;
15258                                                                }
15259                                                            }
15260                                                          else
15261                                                            {
15262                                                              if (((word >> 20) & 0x1) == 0)
15263                                                                {
15264                                                                  /* 33222222222211111111110000000000
15265                                                                     10987654321098765432109876543210
15266                                                                     011001x1xx001100100xxxxxxxxxxxxx
15267                                                                     fdivr.  */
15268                                                                  return 1437;
15269                                                                }
15270                                                              else
15271                                                                {
15272                                                                  /* 33222222222211111111110000000000
15273                                                                     10987654321098765432109876543210
15274                                                                     011001x1xx011100100xxxxxxxxxxxxx
15275                                                                     fmaxnm.  */
15276                                                                  return 1444;
15277                                                                }
15278                                                            }
15279                                                        }
15280                                                      else
15281                                                        {
15282                                                          if (((word >> 18) & 0x1) == 0)
15283                                                            {
15284                                                              if (((word >> 20) & 0x1) == 0)
15285                                                                {
15286                                                                  /* 33222222222211111111110000000000
15287                                                                     10987654321098765432109876543210
15288                                                                     011001x1xx001010100xxxxxxxxxxxxx
15289                                                                     fmulx.  */
15290                                                                  return 1468;
15291                                                                }
15292                                                              else
15293                                                                {
15294                                                                  /* 33222222222211111111110000000000
15295                                                                     10987654321098765432109876543210
15296                                                                     011001x1xx011010100xxxxxxxxxxxxx
15297                                                                     fmul.  */
15298                                                                  return 1464;
15299                                                                }
15300                                                            }
15301                                                          else
15302                                                            {
15303                                                              /* 33222222222211111111110000000000
15304                                                                 10987654321098765432109876543210
15305                                                                 011001x1xx0x1110100xxxxxxxxxxxxx
15306                                                                 fmax.  */
15307                                                              return 1442;
15308                                                            }
15309                                                        }
15310                                                    }
15311                                                  else
15312                                                    {
15313                                                      if (((word >> 17) & 0x1) == 0)
15314                                                        {
15315                                                          if (((word >> 18) & 0x1) == 0)
15316                                                            {
15317                                                              if (((word >> 20) & 0x1) == 0)
15318                                                                {
15319                                                                  /* 33222222222211111111110000000000
15320                                                                     10987654321098765432109876543210
15321                                                                     011001x1xx001001100xxxxxxxxxxxxx
15322                                                                     fscale.  */
15323                                                                  return 1486;
15324                                                                }
15325                                                              else
15326                                                                {
15327                                                                  /* 33222222222211111111110000000000
15328                                                                     10987654321098765432109876543210
15329                                                                     011001x1xx011001100xxxxxxxxxxxxx
15330                                                                     fsub.  */
15331                                                                  return 1490;
15332                                                                }
15333                                                            }
15334                                                          else
15335                                                            {
15336                                                              if (((word >> 20) & 0x1) == 0)
15337                                                                {
15338                                                                  /* 33222222222211111111110000000000
15339                                                                     10987654321098765432109876543210
15340                                                                     011001x1xx001101100xxxxxxxxxxxxx
15341                                                                     fdiv.  */
15342                                                                  return 1436;
15343                                                                }
15344                                                              else
15345                                                                {
15346                                                                  /* 33222222222211111111110000000000
15347                                                                     10987654321098765432109876543210
15348                                                                     011001x1xx011101100xxxxxxxxxxxxx
15349                                                                     fminnm.  */
15350                                                                  return 1450;
15351                                                                }
15352                                                            }
15353                                                        }
15354                                                      else
15355                                                        {
15356                                                          if (((word >> 18) & 0x1) == 0)
15357                                                            {
15358                                                              /* 33222222222211111111110000000000
15359                                                                 10987654321098765432109876543210
15360                                                                 011001x1xx0x1011100xxxxxxxxxxxxx
15361                                                                 fsubr.  */
15362                                                              return 1492;
15363                                                            }
15364                                                          else
15365                                                            {
15366                                                              /* 33222222222211111111110000000000
15367                                                                 10987654321098765432109876543210
15368                                                                 011001x1xx0x1111100xxxxxxxxxxxxx
15369                                                                 fmin.  */
15370                                                              return 1448;
15371                                                            }
15372                                                        }
15373                                                    }
15374                                                }
15375                                            }
15376                                          else
15377                                            {
15378                                              if (((word >> 4) & 0x1) == 0)
15379                                                {
15380                                                  /* 33222222222211111111110000000000
15381                                                     10987654321098765432109876543210
15382                                                     011001x1xx0xxxxx110xxxxxxxx0xxxx
15383                                                     fcmuo.  */
15384                                                  return 1414;
15385                                                }
15386                                              else
15387                                                {
15388                                                  /* 33222222222211111111110000000000
15389                                                     10987654321098765432109876543210
15390                                                     011001x1xx0xxxxx110xxxxxxxx1xxxx
15391                                                     facge.  */
15392                                                  return 1393;
15393                                                }
15394                                            }
15395                                        }
15396                                      else
15397                                        {
15398                                          if (((word >> 22) & 0x1) == 0)
15399                                            {
15400                                              if (((word >> 23) & 0x1) == 0)
15401                                                {
15402                                                  /* 33222222222211111111110000000000
15403                                                     10987654321098765432109876543210
15404                                                     111001x1000xxxxx1x0xxxxxxxxxxxxx
15405                                                     st1w.  */
15406                                                  return 1912;
15407                                                }
15408                                              else
15409                                                {
15410                                                  /* 33222222222211111111110000000000
15411                                                     10987654321098765432109876543210
15412                                                     111001x1100xxxxx1x0xxxxxxxxxxxxx
15413                                                     st1d.  */
15414                                                  return 1891;
15415                                                }
15416                                            }
15417                                          else
15418                                            {
15419                                              /* 33222222222211111111110000000000
15420                                                 10987654321098765432109876543210
15421                                                 111001x1x10xxxxx1x0xxxxxxxxxxxxx
15422                                                 st1w.  */
15423                                              return 1917;
15424                                            }
15425                                        }
15426                                    }
15427                                  else
15428                                    {
15429                                      if (((word >> 14) & 0x1) == 0)
15430                                        {
15431                                          if (((word >> 31) & 0x1) == 0)
15432                                            {
15433                                              if (((word >> 16) & 0x1) == 0)
15434                                                {
15435                                                  if (((word >> 19) & 0x1) == 0)
15436                                                    {
15437                                                      if (((word >> 17) & 0x1) == 0)
15438                                                        {
15439                                                          if (((word >> 18) & 0x1) == 0)
15440                                                            {
15441                                                              if (((word >> 20) & 0x1) == 0)
15442                                                                {
15443                                                                  /* 33222222222211111111110000000000
15444                                                                     10987654321098765432109876543210
15445                                                                     011001x1xx000000101xxxxxxxxxxxxx
15446                                                                     frintn.  */
15447                                                                  return 1480;
15448                                                                }
15449                                                              else
15450                                                                {
15451                                                                  /* 33222222222211111111110000000000
15452                                                                     10987654321098765432109876543210
15453                                                                     011001x1xx010000101xxxxxxxxxxxxx
15454                                                                     scvtf.  */
15455                                                                  return 1826;
15456                                                                }
15457                                                            }
15458                                                          else
15459                                                            {
15460                                                              if (((word >> 20) & 0x1) == 0)
15461                                                                {
15462                                                                  /* 33222222222211111111110000000000
15463                                                                     10987654321098765432109876543210
15464                                                                     011001x1xx000100101xxxxxxxxxxxxx
15465                                                                     frinta.  */
15466                                                                  return 1477;
15467                                                                }
15468                                                              else
15469                                                                {
15470                                                                  if (((word >> 22) & 0x1) == 0)
15471                                                                    {
15472                                                                      /* 33222222222211111111110000000000
15473                                                                         10987654321098765432109876543210
15474                                                                         011001x1x0010100101xxxxxxxxxxxxx
15475                                                                         scvtf.  */
15476                                                                      return 1825;
15477                                                                    }
15478                                                                  else
15479                                                                    {
15480                                                                      if (((word >> 23) & 0x1) == 0)
15481                                                                        {
15482                                                                          /* 33222222222211111111110000000000
15483                                                                             10987654321098765432109876543210
15484                                                                             011001x101010100101xxxxxxxxxxxxx
15485                                                                             scvtf.  */
15486                                                                          return 1824;
15487                                                                        }
15488                                                                      else
15489                                                                        {
15490                                                                          /* 33222222222211111111110000000000
15491                                                                             10987654321098765432109876543210
15492                                                                             011001x111010100101xxxxxxxxxxxxx
15493                                                                             scvtf.  */
15494                                                                          return 1828;
15495                                                                        }
15496                                                                    }
15497                                                                }
15498                                                            }
15499                                                        }
15500                                                      else
15501                                                        {
15502                                                          if (((word >> 18) & 0x1) == 0)
15503                                                            {
15504                                                              if (((word >> 20) & 0x1) == 0)
15505                                                                {
15506                                                                  /* 33222222222211111111110000000000
15507                                                                     10987654321098765432109876543210
15508                                                                     011001x1xx000010101xxxxxxxxxxxxx
15509                                                                     frintm.  */
15510                                                                  return 1479;
15511                                                                }
15512                                                              else
15513                                                                {
15514                                                                  /* 33222222222211111111110000000000
15515                                                                     10987654321098765432109876543210
15516                                                                     011001x1xx010010101xxxxxxxxxxxxx
15517                                                                     scvtf.  */
15518                                                                  return 1823;
15519                                                                }
15520                                                            }
15521                                                          else
15522                                                            {
15523                                                              if (((word >> 20) & 0x1) == 0)
15524                                                                {
15525                                                                  /* 33222222222211111111110000000000
15526                                                                     10987654321098765432109876543210
15527                                                                     011001x1xx000110101xxxxxxxxxxxxx
15528                                                                     frintx.  */
15529                                                                  return 1482;
15530                                                                }
15531                                                              else
15532                                                                {
15533                                                                  if (((word >> 23) & 0x1) == 0)
15534                                                                    {
15535                                                                      /* 33222222222211111111110000000000
15536                                                                         10987654321098765432109876543210
15537                                                                         011001x10x010110101xxxxxxxxxxxxx
15538                                                                         scvtf.  */
15539                                                                      return 1827;
15540                                                                    }
15541                                                                  else
15542                                                                    {
15543                                                                      /* 33222222222211111111110000000000
15544                                                                         10987654321098765432109876543210
15545                                                                         011001x11x010110101xxxxxxxxxxxxx
15546                                                                         scvtf.  */
15547                                                                      return 1829;
15548                                                                    }
15549                                                                }
15550                                                            }
15551                                                        }
15552                                                    }
15553                                                  else
15554                                                    {
15555                                                      if (((word >> 20) & 0x1) == 0)
15556                                                        {
15557                                                          if (((word >> 17) & 0x1) == 0)
15558                                                            {
15559                                                              if (((word >> 18) & 0x1) == 0)
15560                                                                {
15561                                                                  if (((word >> 22) & 0x1) == 0)
15562                                                                    {
15563                                                                      /* 33222222222211111111110000000000
15564                                                                         10987654321098765432109876543210
15565                                                                         011001x1x0001000101xxxxxxxxxxxxx
15566                                                                         fcvt.  */
15567                                                                      return 1416;
15568                                                                    }
15569                                                                  else
15570                                                                    {
15571                                                                      /* 33222222222211111111110000000000
15572                                                                         10987654321098765432109876543210
15573                                                                         011001x1x1001000101xxxxxxxxxxxxx
15574                                                                         fcvt.  */
15575                                                                      return 1418;
15576                                                                    }
15577                                                                }
15578                                                              else
15579                                                                {
15580                                                                  /* 33222222222211111111110000000000
15581                                                                     10987654321098765432109876543210
15582                                                                     011001x1xx001100101xxxxxxxxxxxxx
15583                                                                     frecpx.  */
15584                                                                  return 1476;
15585                                                                }
15586                                                            }
15587                                                          else
15588                                                            {
15589                                                              if (((word >> 22) & 0x1) == 0)
15590                                                                {
15591                                                                  if (((word >> 23) & 0x1) == 0)
15592                                                                    {
15593                                                                      /* 33222222222211111111110000000000
15594                                                                         10987654321098765432109876543210
15595                                                                         011001x100001x10101xxxxxxxxxxxxx
15596                                                                         fcvtx.  */
15597                                                                      return 2086;
15598                                                                    }
15599                                                                  else
15600                                                                    {
15601                                                                      /* 33222222222211111111110000000000
15602                                                                         10987654321098765432109876543210
15603                                                                         011001x110001x10101xxxxxxxxxxxxx
15604                                                                         bfcvt.  */
15605                                                                      return 2498;
15606                                                                    }
15607                                                                }
15608                                                              else
15609                                                                {
15610                                                                  /* 33222222222211111111110000000000
15611                                                                     10987654321098765432109876543210
15612                                                                     011001x1x1001x10101xxxxxxxxxxxxx
15613                                                                     fcvt.  */
15614                                                                  return 1420;
15615                                                                }
15616                                                            }
15617                                                        }
15618                                                      else
15619                                                        {
15620                                                          if (((word >> 22) & 0x1) == 0)
15621                                                            {
15622                                                              if (((word >> 23) & 0x1) == 0)
15623                                                                {
15624                                                                  /* 33222222222211111111110000000000
15625                                                                     10987654321098765432109876543210
15626                                                                     011001x100011xx0101xxxxxxxxxxxxx
15627                                                                     flogb.  */
15628                                                                  return 2088;
15629                                                                }
15630                                                              else
15631                                                                {
15632                                                                  /* 33222222222211111111110000000000
15633                                                                     10987654321098765432109876543210
15634                                                                     011001x110011xx0101xxxxxxxxxxxxx
15635                                                                     fcvtzs.  */
15636                                                                  return 1425;
15637                                                                }
15638                                                            }
15639                                                          else
15640                                                            {
15641                                                              if (((word >> 17) & 0x1) == 0)
15642                                                                {
15643                                                                  if (((word >> 18) & 0x1) == 0)
15644                                                                    {
15645                                                                      /* 33222222222211111111110000000000
15646                                                                         10987654321098765432109876543210
15647                                                                         011001x1x1011000101xxxxxxxxxxxxx
15648                                                                         fcvtzs.  */
15649                                                                      return 1426;
15650                                                                    }
15651                                                                  else
15652                                                                    {
15653                                                                      if (((word >> 23) & 0x1) == 0)
15654                                                                        {
15655                                                                          /* 33222222222211111111110000000000
15656                                                                             10987654321098765432109876543210
15657                                                                             011001x101011100101xxxxxxxxxxxxx
15658                                                                             fcvtzs.  */
15659                                                                          return 1423;
15660                                                                        }
15661                                                                      else
15662                                                                        {
15663                                                                          /* 33222222222211111111110000000000
15664                                                                             10987654321098765432109876543210
15665                                                                             011001x111011100101xxxxxxxxxxxxx
15666                                                                             fcvtzs.  */
15667                                                                          return 1427;
15668                                                                        }
15669                                                                    }
15670                                                                }
15671                                                              else
15672                                                                {
15673                                                                  if (((word >> 18) & 0x1) == 0)
15674                                                                    {
15675                                                                      /* 33222222222211111111110000000000
15676                                                                         10987654321098765432109876543210
15677                                                                         011001x1x1011010101xxxxxxxxxxxxx
15678                                                                         fcvtzs.  */
15679                                                                      return 1422;
15680                                                                    }
15681                                                                  else
15682                                                                    {
15683                                                                      if (((word >> 23) & 0x1) == 0)
15684                                                                        {
15685                                                                          /* 33222222222211111111110000000000
15686                                                                             10987654321098765432109876543210
15687                                                                             011001x101011110101xxxxxxxxxxxxx
15688                                                                             fcvtzs.  */
15689                                                                          return 1424;
15690                                                                        }
15691                                                                      else
15692                                                                        {
15693                                                                          /* 33222222222211111111110000000000
15694                                                                             10987654321098765432109876543210
15695                                                                             011001x111011110101xxxxxxxxxxxxx
15696                                                                             fcvtzs.  */
15697                                                                          return 1428;
15698                                                                        }
15699                                                                    }
15700                                                                }
15701                                                            }
15702                                                        }
15703                                                    }
15704                                                }
15705                                              else
15706                                                {
15707                                                  if (((word >> 17) & 0x1) == 0)
15708                                                    {
15709                                                      if (((word >> 18) & 0x1) == 0)
15710                                                        {
15711                                                          if (((word >> 19) & 0x1) == 0)
15712                                                            {
15713                                                              if (((word >> 20) & 0x1) == 0)
15714                                                                {
15715                                                                  /* 33222222222211111111110000000000
15716                                                                     10987654321098765432109876543210
15717                                                                     011001x1xx000001101xxxxxxxxxxxxx
15718                                                                     frintp.  */
15719                                                                  return 1481;
15720                                                                }
15721                                                              else
15722                                                                {
15723                                                                  /* 33222222222211111111110000000000
15724                                                                     10987654321098765432109876543210
15725                                                                     011001x1xx010001101xxxxxxxxxxxxx
15726                                                                     ucvtf.  */
15727                                                                  return 1978;
15728                                                                }
15729                                                            }
15730                                                          else
15731                                                            {
15732                                                              if (((word >> 20) & 0x1) == 0)
15733                                                                {
15734                                                                  if (((word >> 22) & 0x1) == 0)
15735                                                                    {
15736                                                                      /* 33222222222211111111110000000000
15737                                                                         10987654321098765432109876543210
15738                                                                         011001x1x0001001101xxxxxxxxxxxxx
15739                                                                         fcvt.  */
15740                                                                      return 1417;
15741                                                                    }
15742                                                                  else
15743                                                                    {
15744                                                                      /* 33222222222211111111110000000000
15745                                                                         10987654321098765432109876543210
15746                                                                         011001x1x1001001101xxxxxxxxxxxxx
15747                                                                         fcvt.  */
15748                                                                      return 1419;
15749                                                                    }
15750                                                                }
15751                                                              else
15752                                                                {
15753                                                                  /* 33222222222211111111110000000000
15754                                                                     10987654321098765432109876543210
15755                                                                     011001x1xx011001101xxxxxxxxxxxxx
15756                                                                     fcvtzu.  */
15757                                                                  return 1433;
15758                                                                }
15759                                                            }
15760                                                        }
15761                                                      else
15762                                                        {
15763                                                          if (((word >> 19) & 0x1) == 0)
15764                                                            {
15765                                                              if (((word >> 22) & 0x1) == 0)
15766                                                                {
15767                                                                  /* 33222222222211111111110000000000
15768                                                                     10987654321098765432109876543210
15769                                                                     011001x1x00x0101101xxxxxxxxxxxxx
15770                                                                     ucvtf.  */
15771                                                                  return 1977;
15772                                                                }
15773                                                              else
15774                                                                {
15775                                                                  if (((word >> 23) & 0x1) == 0)
15776                                                                    {
15777                                                                      /* 33222222222211111111110000000000
15778                                                                         10987654321098765432109876543210
15779                                                                         011001x1010x0101101xxxxxxxxxxxxx
15780                                                                         ucvtf.  */
15781                                                                      return 1976;
15782                                                                    }
15783                                                                  else
15784                                                                    {
15785                                                                      /* 33222222222211111111110000000000
15786                                                                         10987654321098765432109876543210
15787                                                                         011001x1110x0101101xxxxxxxxxxxxx
15788                                                                         ucvtf.  */
15789                                                                      return 1980;
15790                                                                    }
15791                                                                }
15792                                                            }
15793                                                          else
15794                                                            {
15795                                                              if (((word >> 20) & 0x1) == 0)
15796                                                                {
15797                                                                  /* 33222222222211111111110000000000
15798                                                                     10987654321098765432109876543210
15799                                                                     011001x1xx001101101xxxxxxxxxxxxx
15800                                                                     fsqrt.  */
15801                                                                  return 1487;
15802                                                                }
15803                                                              else
15804                                                                {
15805                                                                  if (((word >> 22) & 0x1) == 0)
15806                                                                    {
15807                                                                      /* 33222222222211111111110000000000
15808                                                                         10987654321098765432109876543210
15809                                                                         011001x1x0011101101xxxxxxxxxxxxx
15810                                                                         fcvtzu.  */
15811                                                                      return 1432;
15812                                                                    }
15813                                                                  else
15814                                                                    {
15815                                                                      if (((word >> 23) & 0x1) == 0)
15816                                                                        {
15817                                                                          /* 33222222222211111111110000000000
15818                                                                             10987654321098765432109876543210
15819                                                                             011001x101011101101xxxxxxxxxxxxx
15820                                                                             fcvtzu.  */
15821                                                                          return 1430;
15822                                                                        }
15823                                                                      else
15824                                                                        {
15825                                                                          /* 33222222222211111111110000000000
15826                                                                             10987654321098765432109876543210
15827                                                                             011001x111011101101xxxxxxxxxxxxx
15828                                                                             fcvtzu.  */
15829                                                                          return 1434;
15830                                                                        }
15831                                                                    }
15832                                                                }
15833                                                            }
15834                                                        }
15835                                                    }
15836                                                  else
15837                                                    {
15838                                                      if (((word >> 18) & 0x1) == 0)
15839                                                        {
15840                                                          if (((word >> 19) & 0x1) == 0)
15841                                                            {
15842                                                              if (((word >> 20) & 0x1) == 0)
15843                                                                {
15844                                                                  /* 33222222222211111111110000000000
15845                                                                     10987654321098765432109876543210
15846                                                                     011001x1xx000011101xxxxxxxxxxxxx
15847                                                                     frintz.  */
15848                                                                  return 1483;
15849                                                                }
15850                                                              else
15851                                                                {
15852                                                                  /* 33222222222211111111110000000000
15853                                                                     10987654321098765432109876543210
15854                                                                     011001x1xx010011101xxxxxxxxxxxxx
15855                                                                     ucvtf.  */
15856                                                                  return 1975;
15857                                                                }
15858                                                            }
15859                                                          else
15860                                                            {
15861                                                              if (((word >> 20) & 0x1) == 0)
15862                                                                {
15863                                                                  /* 33222222222211111111110000000000
15864                                                                     10987654321098765432109876543210
15865                                                                     011001x1xx001011101xxxxxxxxxxxxx
15866                                                                     fcvt.  */
15867                                                                  return 1421;
15868                                                                }
15869                                                              else
15870                                                                {
15871                                                                  /* 33222222222211111111110000000000
15872                                                                     10987654321098765432109876543210
15873                                                                     011001x1xx011011101xxxxxxxxxxxxx
15874                                                                     fcvtzu.  */
15875                                                                  return 1429;
15876                                                                }
15877                                                            }
15878                                                        }
15879                                                      else
15880                                                        {
15881                                                          if (((word >> 19) & 0x1) == 0)
15882                                                            {
15883                                                              if (((word >> 20) & 0x1) == 0)
15884                                                                {
15885                                                                  /* 33222222222211111111110000000000
15886                                                                     10987654321098765432109876543210
15887                                                                     011001x1xx000111101xxxxxxxxxxxxx
15888                                                                     frinti.  */
15889                                                                  return 1478;
15890                                                                }
15891                                                              else
15892                                                                {
15893                                                                  if (((word >> 23) & 0x1) == 0)
15894                                                                    {
15895                                                                      /* 33222222222211111111110000000000
15896                                                                         10987654321098765432109876543210
15897                                                                         011001x10x010111101xxxxxxxxxxxxx
15898                                                                         ucvtf.  */
15899                                                                      return 1979;
15900                                                                    }
15901                                                                  else
15902                                                                    {
15903                                                                      /* 33222222222211111111110000000000
15904                                                                         10987654321098765432109876543210
15905                                                                         011001x11x010111101xxxxxxxxxxxxx
15906                                                                         ucvtf.  */
15907                                                                      return 1981;
15908                                                                    }
15909                                                                }
15910                                                            }
15911                                                          else
15912                                                            {
15913                                                              if (((word >> 23) & 0x1) == 0)
15914                                                                {
15915                                                                  /* 33222222222211111111110000000000
15916                                                                     10987654321098765432109876543210
15917                                                                     011001x10x0x1111101xxxxxxxxxxxxx
15918                                                                     fcvtzu.  */
15919                                                                  return 1431;
15920                                                                }
15921                                                              else
15922                                                                {
15923                                                                  /* 33222222222211111111110000000000
15924                                                                     10987654321098765432109876543210
15925                                                                     011001x11x0x1111101xxxxxxxxxxxxx
15926                                                                     fcvtzu.  */
15927                                                                  return 1435;
15928                                                                }
15929                                                            }
15930                                                        }
15931                                                    }
15932                                                }
15933                                            }
15934                                          else
15935                                            {
15936                                              if (((word >> 22) & 0x1) == 0)
15937                                                {
15938                                                  if (((word >> 23) & 0x1) == 0)
15939                                                    {
15940                                                      /* 33222222222211111111110000000000
15941                                                         10987654321098765432109876543210
15942                                                         111001x1000xxxxx101xxxxxxxxxxxxx
15943                                                         st1w.  */
15944                                                      return 1913;
15945                                                    }
15946                                                  else
15947                                                    {
15948                                                      /* 33222222222211111111110000000000
15949                                                         10987654321098765432109876543210
15950                                                         111001x1100xxxxx101xxxxxxxxxxxxx
15951                                                         st1d.  */
15952                                                      return 1892;
15953                                                    }
15954                                                }
15955                                              else
15956                                                {
15957                                                  if (((word >> 23) & 0x1) == 0)
15958                                                    {
15959                                                      /* 33222222222211111111110000000000
15960                                                         10987654321098765432109876543210
15961                                                         111001x1010xxxxx101xxxxxxxxxxxxx
15962                                                         st1w.  */
15963                                                      return 1920;
15964                                                    }
15965                                                  else
15966                                                    {
15967                                                      /* 33222222222211111111110000000000
15968                                                         10987654321098765432109876543210
15969                                                         111001x1110xxxxx101xxxxxxxxxxxxx
15970                                                         st1d.  */
15971                                                      return 1896;
15972                                                    }
15973                                                }
15974                                            }
15975                                        }
15976                                      else
15977                                        {
15978                                          if (((word >> 31) & 0x1) == 0)
15979                                            {
15980                                              /* 33222222222211111111110000000000
15981                                                 10987654321098765432109876543210
15982                                                 011001x1xx0xxxxx111xxxxxxxxxxxxx
15983                                                 facgt.  */
15984                                              return 1394;
15985                                            }
15986                                          else
15987                                            {
15988                                              if (((word >> 20) & 0x1) == 0)
15989                                                {
15990                                                  /* 33222222222211111111110000000000
15991                                                     10987654321098765432109876543210
15992                                                     111001x1xx00xxxx111xxxxxxxxxxxxx
15993                                                     st1w.  */
15994                                                  return 1921;
15995                                                }
15996                                              else
15997                                                {
15998                                                  if (((word >> 22) & 0x1) == 0)
15999                                                    {
16000                                                      if (((word >> 23) & 0x1) == 0)
16001                                                        {
16002                                                          /* 33222222222211111111110000000000
16003                                                             10987654321098765432109876543210
16004                                                             111001x10001xxxx111xxxxxxxxxxxxx
16005                                                             stnt1w.  */
16006                                                          return 1955;
16007                                                        }
16008                                                      else
16009                                                        {
16010                                                          /* 33222222222211111111110000000000
16011                                                             10987654321098765432109876543210
16012                                                             111001x11001xxxx111xxxxxxxxxxxxx
16013                                                             stnt1d.  */
16014                                                          return 1951;
16015                                                        }
16016                                                    }
16017                                                  else
16018                                                    {
16019                                                      if (((word >> 23) & 0x1) == 0)
16020                                                        {
16021                                                          /* 33222222222211111111110000000000
16022                                                             10987654321098765432109876543210
16023                                                             111001x10101xxxx111xxxxxxxxxxxxx
16024                                                             st3w.  */
16025                                                          return 1939;
16026                                                        }
16027                                                      else
16028                                                        {
16029                                                          /* 33222222222211111111110000000000
16030                                                             10987654321098765432109876543210
16031                                                             111001x11101xxxx111xxxxxxxxxxxxx
16032                                                             st3d.  */
16033                                                          return 1935;
16034                                                        }
16035                                                    }
16036                                                }
16037                                            }
16038                                        }
16039                                    }
16040                                }
16041                            }
16042                          else
16043                            {
16044                              if (((word >> 30) & 0x1) == 0)
16045                                {
16046                                  if (((word >> 14) & 0x1) == 0)
16047                                    {
16048                                      if (((word >> 20) & 0x1) == 0)
16049                                        {
16050                                          if (((word >> 31) & 0x1) == 0)
16051                                            {
16052                                              if (((word >> 16) & 0x1) == 0)
16053                                                {
16054                                                  if (((word >> 17) & 0x1) == 0)
16055                                                    {
16056                                                      if (((word >> 18) & 0x1) == 0)
16057                                                        {
16058                                                          if (((word >> 19) & 0x1) == 0)
16059                                                            {
16060                                                              /* 33222222222211111111110000000000
16061                                                                 10987654321098765432109876543210
16062                                                                 001001x1xx10000010xxxxxxxxxxxxxx
16063                                                                 cntp.  */
16064                                                              return 1363;
16065                                                            }
16066                                                          else
16067                                                            {
16068                                                              if (((word >> 10) & 0x1) == 0)
16069                                                                {
16070                                                                  if (((word >> 11) & 0x1) == 0)
16071                                                                    {
16072                                                                      if (((word >> 12) & 0x1) == 0)
16073                                                                        {
16074                                                                          /* 33222222222211111111110000000000
16075                                                                             10987654321098765432109876543210
16076                                                                             001001x1xx10100010x000xxxxxxxxxx
16077                                                                             sqincp.  */
16078                                                                          return 1870;
16079                                                                        }
16080                                                                      else
16081                                                                        {
16082                                                                          /* 33222222222211111111110000000000
16083                                                                             10987654321098765432109876543210
16084                                                                             001001x1xx10100010x100xxxxxxxxxx
16085                                                                             wrffr.  */
16086                                                                          return 2043;
16087                                                                        }
16088                                                                    }
16089                                                                  else
16090                                                                    {
16091                                                                      /* 33222222222211111111110000000000
16092                                                                         10987654321098765432109876543210
16093                                                                         001001x1xx10100010xx10xxxxxxxxxx
16094                                                                         sqincp.  */
16095                                                                      return 1872;
16096                                                                    }
16097                                                                }
16098                                                              else
16099                                                                {
16100                                                                  /* 33222222222211111111110000000000
16101                                                                     10987654321098765432109876543210
16102                                                                     001001x1xx10100010xxx1xxxxxxxxxx
16103                                                                     sqincp.  */
16104                                                                  return 1871;
16105                                                                }
16106                                                            }
16107                                                        }
16108                                                      else
16109                                                        {
16110                                                          if (((word >> 11) & 0x1) == 0)
16111                                                            {
16112                                                              if (((word >> 12) & 0x1) == 0)
16113                                                                {
16114                                                                  /* 33222222222211111111110000000000
16115                                                                     10987654321098765432109876543210
16116                                                                     001001x1xx10x10010x00xxxxxxxxxxx
16117                                                                     incp.  */
16118                                                                  return 1501;
16119                                                                }
16120                                                              else
16121                                                                {
16122                                                                  /* 33222222222211111111110000000000
16123                                                                     10987654321098765432109876543210
16124                                                                     001001x1xx10x10010x10xxxxxxxxxxx
16125                                                                     setffr.  */
16126                                                                  return 1837;
16127                                                                }
16128                                                            }
16129                                                          else
16130                                                            {
16131                                                              /* 33222222222211111111110000000000
16132                                                                 10987654321098765432109876543210
16133                                                                 001001x1xx10x10010xx1xxxxxxxxxxx
16134                                                                 incp.  */
16135                                                              return 1502;
16136                                                            }
16137                                                        }
16138                                                    }
16139                                                  else
16140                                                    {
16141                                                      if (((word >> 10) & 0x1) == 0)
16142                                                        {
16143                                                          if (((word >> 11) & 0x1) == 0)
16144                                                            {
16145                                                              /* 33222222222211111111110000000000
16146                                                                 10987654321098765432109876543210
16147                                                                 001001x1xx10xx1010xx00xxxxxxxxxx
16148                                                                 sqdecp.  */
16149                                                              return 1856;
16150                                                            }
16151                                                          else
16152                                                            {
16153                                                              /* 33222222222211111111110000000000
16154                                                                 10987654321098765432109876543210
16155                                                                 001001x1xx10xx1010xx10xxxxxxxxxx
16156                                                                 sqdecp.  */
16157                                                              return 1858;
16158                                                            }
16159                                                        }
16160                                                      else
16161                                                        {
16162                                                          /* 33222222222211111111110000000000
16163                                                             10987654321098765432109876543210
16164                                                             001001x1xx10xx1010xxx1xxxxxxxxxx
16165                                                             sqdecp.  */
16166                                                          return 1857;
16167                                                        }
16168                                                    }
16169                                                }
16170                                              else
16171                                                {
16172                                                  if (((word >> 10) & 0x1) == 0)
16173                                                    {
16174                                                      if (((word >> 11) & 0x1) == 0)
16175                                                        {
16176                                                          if (((word >> 17) & 0x1) == 0)
16177                                                            {
16178                                                              if (((word >> 18) & 0x1) == 0)
16179                                                                {
16180                                                                  /* 33222222222211111111110000000000
16181                                                                     10987654321098765432109876543210
16182                                                                     001001x1xx10x00110xx00xxxxxxxxxx
16183                                                                     uqincp.  */
16184                                                                  return 2018;
16185                                                                }
16186                                                              else
16187                                                                {
16188                                                                  /* 33222222222211111111110000000000
16189                                                                     10987654321098765432109876543210
16190                                                                     001001x1xx10x10110xx00xxxxxxxxxx
16191                                                                     decp.  */
16192                                                                  return 1376;
16193                                                                }
16194                                                            }
16195                                                          else
16196                                                            {
16197                                                              /* 33222222222211111111110000000000
16198                                                                 10987654321098765432109876543210
16199                                                                 001001x1xx10xx1110xx00xxxxxxxxxx
16200                                                                 uqdecp.  */
16201                                                              return 2004;
16202                                                            }
16203                                                        }
16204                                                      else
16205                                                        {
16206                                                          if (((word >> 17) & 0x1) == 0)
16207                                                            {
16208                                                              if (((word >> 18) & 0x1) == 0)
16209                                                                {
16210                                                                  /* 33222222222211111111110000000000
16211                                                                     10987654321098765432109876543210
16212                                                                     001001x1xx10x00110xx10xxxxxxxxxx
16213                                                                     uqincp.  */
16214                                                                  return 2019;
16215                                                                }
16216                                                              else
16217                                                                {
16218                                                                  /* 33222222222211111111110000000000
16219                                                                     10987654321098765432109876543210
16220                                                                     001001x1xx10x10110xx10xxxxxxxxxx
16221                                                                     decp.  */
16222                                                                  return 1377;
16223                                                                }
16224                                                            }
16225                                                          else
16226                                                            {
16227                                                              /* 33222222222211111111110000000000
16228                                                                 10987654321098765432109876543210
16229                                                                 001001x1xx10xx1110xx10xxxxxxxxxx
16230                                                                 uqdecp.  */
16231                                                              return 2005;
16232                                                            }
16233                                                        }
16234                                                    }
16235                                                  else
16236                                                    {
16237                                                      if (((word >> 17) & 0x1) == 0)
16238                                                        {
16239                                                          /* 33222222222211111111110000000000
16240                                                             10987654321098765432109876543210
16241                                                             001001x1xx10xx0110xxx1xxxxxxxxxx
16242                                                             uqincp.  */
16243                                                          return 2020;
16244                                                        }
16245                                                      else
16246                                                        {
16247                                                          /* 33222222222211111111110000000000
16248                                                             10987654321098765432109876543210
16249                                                             001001x1xx10xx1110xxx1xxxxxxxxxx
16250                                                             uqdecp.  */
16251                                                          return 2006;
16252                                                        }
16253                                                    }
16254                                                }
16255                                            }
16256                                          else
16257                                            {
16258                                              if (((word >> 22) & 0x1) == 0)
16259                                                {
16260                                                  if (((word >> 23) & 0x1) == 0)
16261                                                    {
16262                                                      /* 33222222222211111111110000000000
16263                                                         10987654321098765432109876543210
16264                                                         101001x10010xxxx10xxxxxxxxxxxxxx
16265                                                         ld1sh.  */
16266                                                      return 1594;
16267                                                    }
16268                                                  else
16269                                                    {
16270                                                      /* 33222222222211111111110000000000
16271                                                         10987654321098765432109876543210
16272                                                         101001x11010xxxx10xxxxxxxxxxxxxx
16273                                                         ld1sb.  */
16274                                                      return 1581;
16275                                                    }
16276                                                }
16277                                              else
16278                                                {
16279                                                  if (((word >> 23) & 0x1) == 0)
16280                                                    {
16281                                                      /* 33222222222211111111110000000000
16282                                                         10987654321098765432109876543210
16283                                                         101001x10110xxxx10xxxxxxxxxxxxxx
16284                                                         ld1w.  */
16285                                                      return 1613;
16286                                                    }
16287                                                  else
16288                                                    {
16289                                                      /* 33222222222211111111110000000000
16290                                                         10987654321098765432109876543210
16291                                                         101001x11110xxxx10xxxxxxxxxxxxxx
16292                                                         ld1d.  */
16293                                                      return 1533;
16294                                                    }
16295                                                }
16296                                            }
16297                                        }
16298                                      else
16299                                        {
16300                                          if (((word >> 22) & 0x1) == 0)
16301                                            {
16302                                              if (((word >> 23) & 0x1) == 0)
16303                                                {
16304                                                  /* 33222222222211111111110000000000
16305                                                     10987654321098765432109876543210
16306                                                     x01001x10011xxxx10xxxxxxxxxxxxxx
16307                                                     ldnf1sh.  */
16308                                                  return 1727;
16309                                                }
16310                                              else
16311                                                {
16312                                                  /* 33222222222211111111110000000000
16313                                                     10987654321098765432109876543210
16314                                                     x01001x11011xxxx10xxxxxxxxxxxxxx
16315                                                     ldnf1sb.  */
16316                                                  return 1724;
16317                                                }
16318                                            }
16319                                          else
16320                                            {
16321                                              if (((word >> 23) & 0x1) == 0)
16322                                                {
16323                                                  /* 33222222222211111111110000000000
16324                                                     10987654321098765432109876543210
16325                                                     x01001x10111xxxx10xxxxxxxxxxxxxx
16326                                                     ldnf1w.  */
16327                                                  return 1730;
16328                                                }
16329                                              else
16330                                                {
16331                                                  /* 33222222222211111111110000000000
16332                                                     10987654321098765432109876543210
16333                                                     x01001x11111xxxx10xxxxxxxxxxxxxx
16334                                                     ldnf1d.  */
16335                                                  return 1719;
16336                                                }
16337                                            }
16338                                        }
16339                                    }
16340                                  else
16341                                    {
16342                                      if (((word >> 31) & 0x1) == 0)
16343                                        {
16344                                          if (((word >> 16) & 0x1) == 0)
16345                                            {
16346                                              if (((word >> 17) & 0x1) == 0)
16347                                                {
16348                                                  if (((word >> 18) & 0x1) == 0)
16349                                                    {
16350                                                      if (((word >> 19) & 0x1) == 0)
16351                                                        {
16352                                                          if (((word >> 20) & 0x1) == 0)
16353                                                            {
16354                                                              /* 33222222222211111111110000000000
16355                                                                 10987654321098765432109876543210
16356                                                                 001001x1xx10000011xxxxxxxxxxxxxx
16357                                                                 add.  */
16358                                                              return 1290;
16359                                                            }
16360                                                          else
16361                                                            {
16362                                                              /* 33222222222211111111110000000000
16363                                                                 10987654321098765432109876543210
16364                                                                 001001x1xx11000011xxxxxxxxxxxxxx
16365                                                                 mul.  */
16366                                                              return 1759;
16367                                                            }
16368                                                        }
16369                                                      else
16370                                                        {
16371                                                          if (((word >> 20) & 0x1) == 0)
16372                                                            {
16373                                                              /* 33222222222211111111110000000000
16374                                                                 10987654321098765432109876543210
16375                                                                 001001x1xx10100011xxxxxxxxxxxxxx
16376                                                                 smax.  */
16377                                                              return 1838;
16378                                                            }
16379                                                          else
16380                                                            {
16381                                                              /* 33222222222211111111110000000000
16382                                                                 10987654321098765432109876543210
16383                                                                 001001x1xx11100011xxxxxxxxxxxxxx
16384                                                                 dup.  */
16385                                                              return 1382;
16386                                                            }
16387                                                        }
16388                                                    }
16389                                                  else
16390                                                    {
16391                                                      /* 33222222222211111111110000000000
16392                                                         10987654321098765432109876543210
16393                                                         001001x1xx1xx10011xxxxxxxxxxxxxx
16394                                                         sqadd.  */
16395                                                      return 1847;
16396                                                    }
16397                                                }
16398                                              else
16399                                                {
16400                                                  if (((word >> 18) & 0x1) == 0)
16401                                                    {
16402                                                      /* 33222222222211111111110000000000
16403                                                         10987654321098765432109876543210
16404                                                         001001x1xx1xx01011xxxxxxxxxxxxxx
16405                                                         smin.  */
16406                                                      return 1841;
16407                                                    }
16408                                                  else
16409                                                    {
16410                                                      /* 33222222222211111111110000000000
16411                                                         10987654321098765432109876543210
16412                                                         001001x1xx1xx11011xxxxxxxxxxxxxx
16413                                                         sqsub.  */
16414                                                      return 1877;
16415                                                    }
16416                                                }
16417                                            }
16418                                          else
16419                                            {
16420                                              if (((word >> 17) & 0x1) == 0)
16421                                                {
16422                                                  if (((word >> 18) & 0x1) == 0)
16423                                                    {
16424                                                      if (((word >> 19) & 0x1) == 0)
16425                                                        {
16426                                                          /* 33222222222211111111110000000000
16427                                                             10987654321098765432109876543210
16428                                                             001001x1xx1x000111xxxxxxxxxxxxxx
16429                                                             sub.  */
16430                                                          return 1959;
16431                                                        }
16432                                                      else
16433                                                        {
16434                                                          if (((word >> 20) & 0x1) == 0)
16435                                                            {
16436                                                              /* 33222222222211111111110000000000
16437                                                                 10987654321098765432109876543210
16438                                                                 001001x1xx10100111xxxxxxxxxxxxxx
16439                                                                 umax.  */
16440                                                              return 1987;
16441                                                            }
16442                                                          else
16443                                                            {
16444                                                              /* 33222222222211111111110000000000
16445                                                                 10987654321098765432109876543210
16446                                                                 001001x1xx11100111xxxxxxxxxxxxxx
16447                                                                 fdup.  */
16448                                                              return 1438;
16449                                                            }
16450                                                        }
16451                                                    }
16452                                                  else
16453                                                    {
16454                                                      /* 33222222222211111111110000000000
16455                                                         10987654321098765432109876543210
16456                                                         001001x1xx1xx10111xxxxxxxxxxxxxx
16457                                                         uqadd.  */
16458                                                      return 1995;
16459                                                    }
16460                                                }
16461                                              else
16462                                                {
16463                                                  if (((word >> 18) & 0x1) == 0)
16464                                                    {
16465                                                      if (((word >> 19) & 0x1) == 0)
16466                                                        {
16467                                                          /* 33222222222211111111110000000000
16468                                                             10987654321098765432109876543210
16469                                                             001001x1xx1x001111xxxxxxxxxxxxxx
16470                                                             subr.  */
16471                                                          return 1961;
16472                                                        }
16473                                                      else
16474                                                        {
16475                                                          /* 33222222222211111111110000000000
16476                                                             10987654321098765432109876543210
16477                                                             001001x1xx1x101111xxxxxxxxxxxxxx
16478                                                             umin.  */
16479                                                          return 1990;
16480                                                        }
16481                                                    }
16482                                                  else
16483                                                    {
16484                                                      /* 33222222222211111111110000000000
16485                                                         10987654321098765432109876543210
16486                                                         001001x1xx1xx11111xxxxxxxxxxxxxx
16487                                                         uqsub.  */
16488                                                      return 2025;
16489                                                    }
16490                                                }
16491                                            }
16492                                        }
16493                                      else
16494                                        {
16495                                          if (((word >> 13) & 0x1) == 0)
16496                                            {
16497                                              if (((word >> 22) & 0x1) == 0)
16498                                                {
16499                                                  if (((word >> 23) & 0x1) == 0)
16500                                                    {
16501                                                      /* 33222222222211111111110000000000
16502                                                         10987654321098765432109876543210
16503                                                         101001x1001xxxxx110xxxxxxxxxxxxx
16504                                                         ld2w.  */
16505                                                      return 1621;
16506                                                    }
16507                                                  else
16508                                                    {
16509                                                      /* 33222222222211111111110000000000
16510                                                         10987654321098765432109876543210
16511                                                         101001x1101xxxxx110xxxxxxxxxxxxx
16512                                                         ld2d.  */
16513                                                      return 1617;
16514                                                    }
16515                                                }
16516                                              else
16517                                                {
16518                                                  if (((word >> 23) & 0x1) == 0)
16519                                                    {
16520                                                      /* 33222222222211111111110000000000
16521                                                         10987654321098765432109876543210
16522                                                         101001x1011xxxxx110xxxxxxxxxxxxx
16523                                                         ld4w.  */
16524                                                      return 1637;
16525                                                    }
16526                                                  else
16527                                                    {
16528                                                      /* 33222222222211111111110000000000
16529                                                         10987654321098765432109876543210
16530                                                         101001x1111xxxxx110xxxxxxxxxxxxx
16531                                                         ld4d.  */
16532                                                      return 1633;
16533                                                    }
16534                                                }
16535                                            }
16536                                          else
16537                                            {
16538                                              if (((word >> 22) & 0x1) == 0)
16539                                                {
16540                                                  if (((word >> 23) & 0x1) == 0)
16541                                                    {
16542                                                      /* 33222222222211111111110000000000
16543                                                         10987654321098765432109876543210
16544                                                         101001x1001xxxxx111xxxxxxxxxxxxx
16545                                                         ld2w.  */
16546                                                      return 1622;
16547                                                    }
16548                                                  else
16549                                                    {
16550                                                      /* 33222222222211111111110000000000
16551                                                         10987654321098765432109876543210
16552                                                         101001x1101xxxxx111xxxxxxxxxxxxx
16553                                                         ld2d.  */
16554                                                      return 1618;
16555                                                    }
16556                                                }
16557                                              else
16558                                                {
16559                                                  if (((word >> 23) & 0x1) == 0)
16560                                                    {
16561                                                      /* 33222222222211111111110000000000
16562                                                         10987654321098765432109876543210
16563                                                         101001x1011xxxxx111xxxxxxxxxxxxx
16564                                                         ld4w.  */
16565                                                      return 1638;
16566                                                    }
16567                                                  else
16568                                                    {
16569                                                      /* 33222222222211111111110000000000
16570                                                         10987654321098765432109876543210
16571                                                         101001x1111xxxxx111xxxxxxxxxxxxx
16572                                                         ld4d.  */
16573                                                      return 1634;
16574                                                    }
16575                                                }
16576                                            }
16577                                        }
16578                                    }
16579                                }
16580                              else
16581                                {
16582                                  if (((word >> 13) & 0x1) == 0)
16583                                    {
16584                                      if (((word >> 31) & 0x1) == 0)
16585                                        {
16586                                          if (((word >> 14) & 0x1) == 0)
16587                                            {
16588                                              /* 33222222222211111111110000000000
16589                                                 10987654321098765432109876543210
16590                                                 011001x1xx1xxxxx100xxxxxxxxxxxxx
16591                                                 fmad.  */
16592                                              return 1440;
16593                                            }
16594                                          else
16595                                            {
16596                                              /* 33222222222211111111110000000000
16597                                                 10987654321098765432109876543210
16598                                                 011001x1xx1xxxxx110xxxxxxxxxxxxx
16599                                                 fnmad.  */
16600                                              return 1470;
16601                                            }
16602                                        }
16603                                      else
16604                                        {
16605                                          if (((word >> 22) & 0x1) == 0)
16606                                            {
16607                                              if (((word >> 23) & 0x1) == 0)
16608                                                {
16609                                                  /* 33222222222211111111110000000000
16610                                                     10987654321098765432109876543210
16611                                                     111001x1001xxxxx1x0xxxxxxxxxxxxx
16612                                                     st1w.  */
16613                                                  return 1914;
16614                                                }
16615                                              else
16616                                                {
16617                                                  /* 33222222222211111111110000000000
16618                                                     10987654321098765432109876543210
16619                                                     111001x1101xxxxx1x0xxxxxxxxxxxxx
16620                                                     st1d.  */
16621                                                  return 1893;
16622                                                }
16623                                            }
16624                                          else
16625                                            {
16626                                              /* 33222222222211111111110000000000
16627                                                 10987654321098765432109876543210
16628                                                 111001x1x11xxxxx1x0xxxxxxxxxxxxx
16629                                                 st1w.  */
16630                                              return 1919;
16631                                            }
16632                                        }
16633                                    }
16634                                  else
16635                                    {
16636                                      if (((word >> 14) & 0x1) == 0)
16637                                        {
16638                                          if (((word >> 31) & 0x1) == 0)
16639                                            {
16640                                              /* 33222222222211111111110000000000
16641                                                 10987654321098765432109876543210
16642                                                 011001x1xx1xxxxx101xxxxxxxxxxxxx
16643                                                 fmsb.  */
16644                                              return 1461;
16645                                            }
16646                                          else
16647                                            {
16648                                              if (((word >> 22) & 0x1) == 0)
16649                                                {
16650                                                  if (((word >> 23) & 0x1) == 0)
16651                                                    {
16652                                                      /* 33222222222211111111110000000000
16653                                                         10987654321098765432109876543210
16654                                                         111001x1001xxxxx101xxxxxxxxxxxxx
16655                                                         st1w.  */
16656                                                      return 1915;
16657                                                    }
16658                                                  else
16659                                                    {
16660                                                      /* 33222222222211111111110000000000
16661                                                         10987654321098765432109876543210
16662                                                         111001x1101xxxxx101xxxxxxxxxxxxx
16663                                                         st1d.  */
16664                                                      return 1894;
16665                                                    }
16666                                                }
16667                                              else
16668                                                {
16669                                                  /* 33222222222211111111110000000000
16670                                                     10987654321098765432109876543210
16671                                                     111001x1x11xxxxx101xxxxxxxxxxxxx
16672                                                     st1w.  */
16673                                                  return 1922;
16674                                                }
16675                                            }
16676                                        }
16677                                      else
16678                                        {
16679                                          if (((word >> 31) & 0x1) == 0)
16680                                            {
16681                                              /* 33222222222211111111110000000000
16682                                                 10987654321098765432109876543210
16683                                                 011001x1xx1xxxxx111xxxxxxxxxxxxx
16684                                                 fnmsb.  */
16685                                              return 1473;
16686                                            }
16687                                          else
16688                                            {
16689                                              if (((word >> 20) & 0x1) == 0)
16690                                                {
16691                                                  if (((word >> 23) & 0x1) == 0)
16692                                                    {
16693                                                      /* 33222222222211111111110000000000
16694                                                         10987654321098765432109876543210
16695                                                         111001x10x10xxxx111xxxxxxxxxxxxx
16696                                                         st1w.  */
16697                                                      return 1923;
16698                                                    }
16699                                                  else
16700                                                    {
16701                                                      /* 33222222222211111111110000000000
16702                                                         10987654321098765432109876543210
16703                                                         111001x11x10xxxx111xxxxxxxxxxxxx
16704                                                         st1d.  */
16705                                                      return 1897;
16706                                                    }
16707                                                }
16708                                              else
16709                                                {
16710                                                  if (((word >> 22) & 0x1) == 0)
16711                                                    {
16712                                                      if (((word >> 23) & 0x1) == 0)
16713                                                        {
16714                                                          /* 33222222222211111111110000000000
16715                                                             10987654321098765432109876543210
16716                                                             111001x10011xxxx111xxxxxxxxxxxxx
16717                                                             st2w.  */
16718                                                          return 1931;
16719                                                        }
16720                                                      else
16721                                                        {
16722                                                          /* 33222222222211111111110000000000
16723                                                             10987654321098765432109876543210
16724                                                             111001x11011xxxx111xxxxxxxxxxxxx
16725                                                             st2d.  */
16726                                                          return 1927;
16727                                                        }
16728                                                    }
16729                                                  else
16730                                                    {
16731                                                      if (((word >> 23) & 0x1) == 0)
16732                                                        {
16733                                                          /* 33222222222211111111110000000000
16734                                                             10987654321098765432109876543210
16735                                                             111001x10111xxxx111xxxxxxxxxxxxx
16736                                                             st4w.  */
16737                                                          return 1947;
16738                                                        }
16739                                                      else
16740                                                        {
16741                                                          /* 33222222222211111111110000000000
16742                                                             10987654321098765432109876543210
16743                                                             111001x11111xxxx111xxxxxxxxxxxxx
16744                                                             st4d.  */
16745                                                          return 1943;
16746                                                        }
16747                                                    }
16748                                                }
16749                                            }
16750                                        }
16751                                    }
16752                                }
16753                            }
16754                        }
16755                    }
16756                }
16757            }
16758          else
16759            {
16760              if (((word >> 29) & 0x1) == 0)
16761                {
16762                  if (((word >> 30) & 0x1) == 0)
16763                    {
16764                      if (((word >> 31) & 0x1) == 0)
16765                        {
16766                          /* 33222222222211111111110000000000
16767                             10987654321098765432109876543210
16768                             000101xxxxxxxxxxxxxxxxxxxxxxxxxx
16769                             b.  */
16770                          return 636;
16771                        }
16772                      else
16773                        {
16774                          /* 33222222222211111111110000000000
16775                             10987654321098765432109876543210
16776                             100101xxxxxxxxxxxxxxxxxxxxxxxxxx
16777                             bl.  */
16778                          return 637;
16779                        }
16780                    }
16781                  else
16782                    {
16783                      if (((word >> 24) & 0x1) == 0)
16784                        {
16785                          if (((word >> 4) & 0x1) == 0)
16786                            {
16787                              if (((word >> 25) & 0x1) == 0)
16788                                {
16789                                  if (((word >> 31) & 0x1) == 0)
16790                                    {
16791                                      /* 33222222222211111111110000000000
16792                                         10987654321098765432109876543210
16793                                         01010100xxxxxxxxxxxxxxxxxxx0xxxx
16794                                         b.c.  */
16795                                      return 657;
16796                                    }
16797                                  else
16798                                    {
16799                                      if (((word >> 0) & 0x1) == 0)
16800                                        {
16801                                          if (((word >> 1) & 0x1) == 0)
16802                                            {
16803                                              if (((word >> 21) & 0x1) == 0)
16804                                                {
16805                                                  /* 33222222222211111111110000000000
16806                                                     10987654321098765432109876543210
16807                                                     11010100xx0xxxxxxxxxxxxxxxx0xx00
16808                                                     hlt.  */
16809                                                  return 753;
16810                                                }
16811                                              else
16812                                                {
16813                                                  if (((word >> 22) & 0x1) == 0)
16814                                                    {
16815                                                      /* 33222222222211111111110000000000
16816                                                         10987654321098765432109876543210
16817                                                         11010100x01xxxxxxxxxxxxxxxx0xx00
16818                                                         brk.  */
16819                                                      return 752;
16820                                                    }
16821                                                  else
16822                                                    {
16823                                                      /* 33222222222211111111110000000000
16824                                                         10987654321098765432109876543210
16825                                                         11010100x11xxxxxxxxxxxxxxxx0xx00
16826                                                         tcancel.  */
16827                                                      return 1196;
16828                                                    }
16829                                                }
16830                                            }
16831                                          else
16832                                            {
16833                                              if (((word >> 21) & 0x1) == 0)
16834                                                {
16835                                                  /* 33222222222211111111110000000000
16836                                                     10987654321098765432109876543210
16837                                                     11010100xx0xxxxxxxxxxxxxxxx0xx10
16838                                                     hvc.  */
16839                                                  return 750;
16840                                                }
16841                                              else
16842                                                {
16843                                                  /* 33222222222211111111110000000000
16844                                                     10987654321098765432109876543210
16845                                                     11010100xx1xxxxxxxxxxxxxxxx0xx10
16846                                                     dcps2.  */
16847                                                  return 756;
16848                                                }
16849                                            }
16850                                        }
16851                                      else
16852                                        {
16853                                          if (((word >> 1) & 0x1) == 0)
16854                                            {
16855                                              if (((word >> 21) & 0x1) == 0)
16856                                                {
16857                                                  /* 33222222222211111111110000000000
16858                                                     10987654321098765432109876543210
16859                                                     11010100xx0xxxxxxxxxxxxxxxx0xx01
16860                                                     svc.  */
16861                                                  return 749;
16862                                                }
16863                                              else
16864                                                {
16865                                                  /* 33222222222211111111110000000000
16866                                                     10987654321098765432109876543210
16867                                                     11010100xx1xxxxxxxxxxxxxxxx0xx01
16868                                                     dcps1.  */
16869                                                  return 755;
16870                                                }
16871                                            }
16872                                          else
16873                                            {
16874                                              if (((word >> 21) & 0x1) == 0)
16875                                                {
16876                                                  /* 33222222222211111111110000000000
16877                                                     10987654321098765432109876543210
16878                                                     11010100xx0xxxxxxxxxxxxxxxx0xx11
16879                                                     smc.  */
16880                                                  return 751;
16881                                                }
16882                                              else
16883                                                {
16884                                                  /* 33222222222211111111110000000000
16885                                                     10987654321098765432109876543210
16886                                                     11010100xx1xxxxxxxxxxxxxxxx0xx11
16887                                                     dcps3.  */
16888                                                  return 757;
16889                                                }
16890                                            }
16891                                        }
16892                                    }
16893                                }
16894                              else
16895                                {
16896                                  if (((word >> 21) & 0x1) == 0)
16897                                    {
16898                                      if (((word >> 22) & 0x1) == 0)
16899                                        {
16900                                          if (((word >> 23) & 0x1) == 0)
16901                                            {
16902                                              /* 33222222222211111111110000000000
16903                                                 10987654321098765432109876543210
16904                                                 x1010110000xxxxxxxxxxxxxxxx0xxxx
16905                                                 br.  */
16906                                              return 638;
16907                                            }
16908                                          else
16909                                            {
16910                                              /* 33222222222211111111110000000000
16911                                                 10987654321098765432109876543210
16912                                                 x1010110100xxxxxxxxxxxxxxxx0xxxx
16913                                                 eret.  */
16914                                              return 641;
16915                                            }
16916                                        }
16917                                      else
16918                                        {
16919                                          /* 33222222222211111111110000000000
16920                                             10987654321098765432109876543210
16921                                             x1010110x10xxxxxxxxxxxxxxxx0xxxx
16922                                             ret.  */
16923                                          return 640;
16924                                        }
16925                                    }
16926                                  else
16927                                    {
16928                                      if (((word >> 23) & 0x1) == 0)
16929                                        {
16930                                          /* 33222222222211111111110000000000
16931                                             10987654321098765432109876543210
16932                                             x10101100x1xxxxxxxxxxxxxxxx0xxxx
16933                                             blr.  */
16934                                          return 639;
16935                                        }
16936                                      else
16937                                        {
16938                                          /* 33222222222211111111110000000000
16939                                             10987654321098765432109876543210
16940                                             x10101101x1xxxxxxxxxxxxxxxx0xxxx
16941                                             drps.  */
16942                                          return 642;
16943                                        }
16944                                    }
16945                                }
16946                            }
16947                          else
16948                            {
16949                              if (((word >> 25) & 0x1) == 0)
16950                                {
16951                                  /* 33222222222211111111110000000000
16952                                     10987654321098765432109876543210
16953                                     x1010100xxxxxxxxxxxxxxxxxxx1xxxx
16954                                     bc.c.  */
16955                                  return 2634;
16956                                }
16957                              else
16958                                {
16959                                  if (((word >> 10) & 0x1) == 0)
16960                                    {
16961                                      if (((word >> 21) & 0x1) == 0)
16962                                        {
16963                                          if (((word >> 22) & 0x1) == 0)
16964                                            {
16965                                              if (((word >> 23) & 0x1) == 0)
16966                                                {
16967                                                  /* 33222222222211111111110000000000
16968                                                     10987654321098765432109876543210
16969                                                     x1010110000xxxxxxxxxx0xxxxx1xxxx
16970                                                     braaz.  */
16971                                                  return 647;
16972                                                }
16973                                              else
16974                                                {
16975                                                  /* 33222222222211111111110000000000
16976                                                     10987654321098765432109876543210
16977                                                     x1010110100xxxxxxxxxx0xxxxx1xxxx
16978                                                     eretaa.  */
16979                                                  return 653;
16980                                                }
16981                                            }
16982                                          else
16983                                            {
16984                                              /* 33222222222211111111110000000000
16985                                                 10987654321098765432109876543210
16986                                                 x1010110x10xxxxxxxxxx0xxxxx1xxxx
16987                                                 retaa.  */
16988                                              return 651;
16989                                            }
16990                                        }
16991                                      else
16992                                        {
16993                                          /* 33222222222211111111110000000000
16994                                             10987654321098765432109876543210
16995                                             x1010110xx1xxxxxxxxxx0xxxxx1xxxx
16996                                             blraaz.  */
16997                                          return 649;
16998                                        }
16999                                    }
17000                                  else
17001                                    {
17002                                      if (((word >> 21) & 0x1) == 0)
17003                                        {
17004                                          if (((word >> 22) & 0x1) == 0)
17005                                            {
17006                                              if (((word >> 23) & 0x1) == 0)
17007                                                {
17008                                                  /* 33222222222211111111110000000000
17009                                                     10987654321098765432109876543210
17010                                                     x1010110000xxxxxxxxxx1xxxxx1xxxx
17011                                                     brabz.  */
17012                                                  return 648;
17013                                                }
17014                                              else
17015                                                {
17016                                                  /* 33222222222211111111110000000000
17017                                                     10987654321098765432109876543210
17018                                                     x1010110100xxxxxxxxxx1xxxxx1xxxx
17019                                                     eretab.  */
17020                                                  return 654;
17021                                                }
17022                                            }
17023                                          else
17024                                            {
17025                                              /* 33222222222211111111110000000000
17026                                                 10987654321098765432109876543210
17027                                                 x1010110x10xxxxxxxxxx1xxxxx1xxxx
17028                                                 retab.  */
17029                                              return 652;
17030                                            }
17031                                        }
17032                                      else
17033                                        {
17034                                          /* 33222222222211111111110000000000
17035                                             10987654321098765432109876543210
17036                                             x1010110xx1xxxxxxxxxx1xxxxx1xxxx
17037                                             blrabz.  */
17038                                          return 650;
17039                                        }
17040                                    }
17041                                }
17042                            }
17043                        }
17044                      else
17045                        {
17046                          if (((word >> 21) & 0x1) == 0)
17047                            {
17048                              if (((word >> 25) & 0x1) == 0)
17049                                {
17050                                  /* 33222222222211111111110000000000
17051                                     10987654321098765432109876543210
17052                                     x1010101xx0xxxxxxxxxxxxxxxxxxxxx
17053                                     xaflag.  */
17054                                  return 811;
17055                                }
17056                              else
17057                                {
17058                                  if (((word >> 10) & 0x1) == 0)
17059                                    {
17060                                      /* 33222222222211111111110000000000
17061                                         10987654321098765432109876543210
17062                                         x1010111xx0xxxxxxxxxx0xxxxxxxxxx
17063                                         braa.  */
17064                                      return 643;
17065                                    }
17066                                  else
17067                                    {
17068                                      /* 33222222222211111111110000000000
17069                                         10987654321098765432109876543210
17070                                         x1010111xx0xxxxxxxxxx1xxxxxxxxxx
17071                                         brab.  */
17072                                      return 644;
17073                                    }
17074                                }
17075                            }
17076                          else
17077                            {
17078                              if (((word >> 25) & 0x1) == 0)
17079                                {
17080                                  /* 33222222222211111111110000000000
17081                                     10987654321098765432109876543210
17082                                     x1010101xx1xxxxxxxxxxxxxxxxxxxxx
17083                                     tstart.  */
17084                                  return 1193;
17085                                }
17086                              else
17087                                {
17088                                  if (((word >> 10) & 0x1) == 0)
17089                                    {
17090                                      /* 33222222222211111111110000000000
17091                                         10987654321098765432109876543210
17092                                         x1010111xx1xxxxxxxxxx0xxxxxxxxxx
17093                                         blraa.  */
17094                                      return 645;
17095                                    }
17096                                  else
17097                                    {
17098                                      /* 33222222222211111111110000000000
17099                                         10987654321098765432109876543210
17100                                         x1010111xx1xxxxxxxxxx1xxxxxxxxxx
17101                                         blrab.  */
17102                                      return 646;
17103                                    }
17104                                }
17105                            }
17106                        }
17107                    }
17108                }
17109              else
17110                {
17111                  if (((word >> 24) & 0x1) == 0)
17112                    {
17113                      if (((word >> 25) & 0x1) == 0)
17114                        {
17115                          /* 33222222222211111111110000000000
17116                             10987654321098765432109876543210
17117                             xx110100xxxxxxxxxxxxxxxxxxxxxxxx
17118                             cbz.  */
17119                          return 655;
17120                        }
17121                      else
17122                        {
17123                          /* 33222222222211111111110000000000
17124                             10987654321098765432109876543210
17125                             xx110110xxxxxxxxxxxxxxxxxxxxxxxx
17126                             tbz.  */
17127                          return 1251;
17128                        }
17129                    }
17130                  else
17131                    {
17132                      if (((word >> 25) & 0x1) == 0)
17133                        {
17134                          /* 33222222222211111111110000000000
17135                             10987654321098765432109876543210
17136                             xx110101xxxxxxxxxxxxxxxxxxxxxxxx
17137                             cbnz.  */
17138                          return 656;
17139                        }
17140                      else
17141                        {
17142                          /* 33222222222211111111110000000000
17143                             10987654321098765432109876543210
17144                             xx110111xxxxxxxxxxxxxxxxxxxxxxxx
17145                             tbnz.  */
17146                          return 1252;
17147                        }
17148                    }
17149                }
17150            }
17151        }
17152      else
17153        {
17154          if (((word >> 25) & 0x1) == 0)
17155            {
17156              if (((word >> 28) & 0x1) == 0)
17157                {
17158                  if (((word >> 22) & 0x1) == 0)
17159                    {
17160                      if (((word >> 23) & 0x1) == 0)
17161                        {
17162                          if (((word >> 24) & 0x1) == 0)
17163                            {
17164                              if (((word >> 29) & 0x1) == 0)
17165                                {
17166                                  /* 33222222222211111111110000000000
17167                                     10987654321098765432109876543210
17168                                     xx00110000xxxxxxxxxxxxxxxxxxxxxx
17169                                     st4.  */
17170                                  return 440;
17171                                }
17172                              else
17173                                {
17174                                  /* 33222222222211111111110000000000
17175                                     10987654321098765432109876543210
17176                                     xx10110000xxxxxxxxxxxxxxxxxxxxxx
17177                                     stnp.  */
17178                                  return 973;
17179                                }
17180                            }
17181                          else
17182                            {
17183                              if (((word >> 29) & 0x1) == 0)
17184                                {
17185                                  if (((word >> 13) & 0x1) == 0)
17186                                    {
17187                                      if (((word >> 21) & 0x1) == 0)
17188                                        {
17189                                          /* 33222222222211111111110000000000
17190                                             10987654321098765432109876543210
17191                                             xx001101000xxxxxxx0xxxxxxxxxxxxx
17192                                             st1.  */
17193                                          return 456;
17194                                        }
17195                                      else
17196                                        {
17197                                          /* 33222222222211111111110000000000
17198                                             10987654321098765432109876543210
17199                                             xx001101001xxxxxxx0xxxxxxxxxxxxx
17200                                             st2.  */
17201                                          return 458;
17202                                        }
17203                                    }
17204                                  else
17205                                    {
17206                                      if (((word >> 21) & 0x1) == 0)
17207                                        {
17208                                          /* 33222222222211111111110000000000
17209                                             10987654321098765432109876543210
17210                                             xx001101000xxxxxxx1xxxxxxxxxxxxx
17211                                             st3.  */
17212                                          return 457;
17213                                        }
17214                                      else
17215                                        {
17216                                          /* 33222222222211111111110000000000
17217                                             10987654321098765432109876543210
17218                                             xx001101001xxxxxxx1xxxxxxxxxxxxx
17219                                             st4.  */
17220                                          return 459;
17221                                        }
17222                                    }
17223                                }
17224                              else
17225                                {
17226                                  /* 33222222222211111111110000000000
17227                                     10987654321098765432109876543210
17228                                     xx10110100xxxxxxxxxxxxxxxxxxxxxx
17229                                     stp.  */
17230                                  return 977;
17231                                }
17232                            }
17233                        }
17234                      else
17235                        {
17236                          if (((word >> 29) & 0x1) == 0)
17237                            {
17238                              if (((word >> 21) & 0x1) == 0)
17239                                {
17240                                  if (((word >> 24) & 0x1) == 0)
17241                                    {
17242                                      /* 33222222222211111111110000000000
17243                                         10987654321098765432109876543210
17244                                         xx001100100xxxxxxxxxxxxxxxxxxxxx
17245                                         st4.  */
17246                                      return 448;
17247                                    }
17248                                  else
17249                                    {
17250                                      if (((word >> 13) & 0x1) == 0)
17251                                        {
17252                                          /* 33222222222211111111110000000000
17253                                             10987654321098765432109876543210
17254                                             xx001101100xxxxxxx0xxxxxxxxxxxxx
17255                                             st1.  */
17256                                          return 468;
17257                                        }
17258                                      else
17259                                        {
17260                                          /* 33222222222211111111110000000000
17261                                             10987654321098765432109876543210
17262                                             xx001101100xxxxxxx1xxxxxxxxxxxxx
17263                                             st3.  */
17264                                          return 469;
17265                                        }
17266                                    }
17267                                }
17268                              else
17269                                {
17270                                  if (((word >> 13) & 0x1) == 0)
17271                                    {
17272                                      /* 33222222222211111111110000000000
17273                                         10987654321098765432109876543210
17274                                         xx00110x101xxxxxxx0xxxxxxxxxxxxx
17275                                         st2.  */
17276                                      return 470;
17277                                    }
17278                                  else
17279                                    {
17280                                      /* 33222222222211111111110000000000
17281                                         10987654321098765432109876543210
17282                                         xx00110x101xxxxxxx1xxxxxxxxxxxxx
17283                                         st4.  */
17284                                      return 471;
17285                                    }
17286                                }
17287                            }
17288                          else
17289                            {
17290                              /* 33222222222211111111110000000000
17291                                 10987654321098765432109876543210
17292                                 xx10110x10xxxxxxxxxxxxxxxxxxxxxx
17293                                 stp.  */
17294                              return 983;
17295                            }
17296                        }
17297                    }
17298                  else
17299                    {
17300                      if (((word >> 23) & 0x1) == 0)
17301                        {
17302                          if (((word >> 24) & 0x1) == 0)
17303                            {
17304                              if (((word >> 29) & 0x1) == 0)
17305                                {
17306                                  /* 33222222222211111111110000000000
17307                                     10987654321098765432109876543210
17308                                     xx00110001xxxxxxxxxxxxxxxxxxxxxx
17309                                     ld4.  */
17310                                  return 444;
17311                                }
17312                              else
17313                                {
17314                                  /* 33222222222211111111110000000000
17315                                     10987654321098765432109876543210
17316                                     xx10110001xxxxxxxxxxxxxxxxxxxxxx
17317                                     ldnp.  */
17318                                  return 974;
17319                                }
17320                            }
17321                          else
17322                            {
17323                              if (((word >> 29) & 0x1) == 0)
17324                                {
17325                                  if (((word >> 13) & 0x1) == 0)
17326                                    {
17327                                      if (((word >> 21) & 0x1) == 0)
17328                                        {
17329                                          /* 33222222222211111111110000000000
17330                                             10987654321098765432109876543210
17331                                             xx001101010xxxxxxx0xxxxxxxxxxxxx
17332                                             ld1.  */
17333                                          return 460;
17334                                        }
17335                                      else
17336                                        {
17337                                          /* 33222222222211111111110000000000
17338                                             10987654321098765432109876543210
17339                                             xx001101011xxxxxxx0xxxxxxxxxxxxx
17340                                             ld2.  */
17341                                          return 464;
17342                                        }
17343                                    }
17344                                  else
17345                                    {
17346                                      if (((word >> 21) & 0x1) == 0)
17347                                        {
17348                                          /* 33222222222211111111110000000000
17349                                             10987654321098765432109876543210
17350                                             xx001101010xxxxxxx1xxxxxxxxxxxxx
17351                                             ld3.  */
17352                                          return 461;
17353                                        }
17354                                      else
17355                                        {
17356                                          /* 33222222222211111111110000000000
17357                                             10987654321098765432109876543210
17358                                             xx001101011xxxxxxx1xxxxxxxxxxxxx
17359                                             ld4.  */
17360                                          return 465;
17361                                        }
17362                                    }
17363                                }
17364                              else
17365                                {
17366                                  /* 33222222222211111111110000000000
17367                                     10987654321098765432109876543210
17368                                     xx10110101xxxxxxxxxxxxxxxxxxxxxx
17369                                     ldp.  */
17370                                  return 978;
17371                                }
17372                            }
17373                        }
17374                      else
17375                        {
17376                          if (((word >> 29) & 0x1) == 0)
17377                            {
17378                              if (((word >> 21) & 0x1) == 0)
17379                                {
17380                                  if (((word >> 24) & 0x1) == 0)
17381                                    {
17382                                      /* 33222222222211111111110000000000
17383                                         10987654321098765432109876543210
17384                                         xx001100110xxxxxxxxxxxxxxxxxxxxx
17385                                         ld4.  */
17386                                      return 452;
17387                                    }
17388                                  else
17389                                    {
17390                                      if (((word >> 13) & 0x1) == 0)
17391                                        {
17392                                          /* 33222222222211111111110000000000
17393                                             10987654321098765432109876543210
17394                                             xx001101110xxxxxxx0xxxxxxxxxxxxx
17395                                             ld1.  */
17396                                          return 472;
17397                                        }
17398                                      else
17399                                        {
17400                                          /* 33222222222211111111110000000000
17401                                             10987654321098765432109876543210
17402                                             xx001101110xxxxxxx1xxxxxxxxxxxxx
17403                                             ld3.  */
17404                                          return 473;
17405                                        }
17406                                    }
17407                                }
17408                              else
17409                                {
17410                                  if (((word >> 13) & 0x1) == 0)
17411                                    {
17412                                      /* 33222222222211111111110000000000
17413                                         10987654321098765432109876543210
17414                                         xx00110x111xxxxxxx0xxxxxxxxxxxxx
17415                                         ld2.  */
17416                                      return 476;
17417                                    }
17418                                  else
17419                                    {
17420                                      /* 33222222222211111111110000000000
17421                                         10987654321098765432109876543210
17422                                         xx00110x111xxxxxxx1xxxxxxxxxxxxx
17423                                         ld4.  */
17424                                      return 477;
17425                                    }
17426                                }
17427                            }
17428                          else
17429                            {
17430                              /* 33222222222211111111110000000000
17431                                 10987654321098765432109876543210
17432                                 xx10110x11xxxxxxxxxxxxxxxxxxxxxx
17433                                 ldp.  */
17434                              return 984;
17435                            }
17436                        }
17437                    }
17438                }
17439              else
17440                {
17441                  if (((word >> 24) & 0x1) == 0)
17442                    {
17443                      if (((word >> 29) & 0x1) == 0)
17444                        {
17445                          /* 33222222222211111111110000000000
17446                             10987654321098765432109876543210
17447                             xx011100xxxxxxxxxxxxxxxxxxxxxxxx
17448                             ldr.  */
17449                          return 988;
17450                        }
17451                      else
17452                        {
17453                          if (((word >> 10) & 0x1) == 0)
17454                            {
17455                              if (((word >> 11) & 0x1) == 0)
17456                                {
17457                                  if (((word >> 22) & 0x1) == 0)
17458                                    {
17459                                      /* 33222222222211111111110000000000
17460                                         10987654321098765432109876543210
17461                                         xx111100x0xxxxxxxxxx00xxxxxxxxxx
17462                                         stur.  */
17463                                      return 925;
17464                                    }
17465                                  else
17466                                    {
17467                                      /* 33222222222211111111110000000000
17468                                         10987654321098765432109876543210
17469                                         xx111100x1xxxxxxxxxx00xxxxxxxxxx
17470                                         ldur.  */
17471                                      return 926;
17472                                    }
17473                                }
17474                              else
17475                                {
17476                                  if (((word >> 22) & 0x1) == 0)
17477                                    {
17478                                      /* 33222222222211111111110000000000
17479                                         10987654321098765432109876543210
17480                                         xx111100x0xxxxxxxxxx10xxxxxxxxxx
17481                                         str.  */
17482                                      return 904;
17483                                    }
17484                                  else
17485                                    {
17486                                      /* 33222222222211111111110000000000
17487                                         10987654321098765432109876543210
17488                                         xx111100x1xxxxxxxxxx10xxxxxxxxxx
17489                                         ldr.  */
17490                                      return 905;
17491                                    }
17492                                }
17493                            }
17494                          else
17495                            {
17496                              if (((word >> 22) & 0x1) == 0)
17497                                {
17498                                  /* 33222222222211111111110000000000
17499                                     10987654321098765432109876543210
17500                                     xx111100x0xxxxxxxxxxx1xxxxxxxxxx
17501                                     str.  */
17502                                  return 873;
17503                                }
17504                              else
17505                                {
17506                                  /* 33222222222211111111110000000000
17507                                     10987654321098765432109876543210
17508                                     xx111100x1xxxxxxxxxxx1xxxxxxxxxx
17509                                     ldr.  */
17510                                  return 874;
17511                                }
17512                            }
17513                        }
17514                    }
17515                  else
17516                    {
17517                      if (((word >> 22) & 0x1) == 0)
17518                        {
17519                          if (((word >> 29) & 0x1) == 0)
17520                            {
17521                              if (((word >> 12) & 0x1) == 0)
17522                                {
17523                                  if (((word >> 13) & 0x1) == 0)
17524                                    {
17525                                      if (((word >> 14) & 0x1) == 0)
17526                                        {
17527                                          if (((word >> 15) & 0x1) == 0)
17528                                            {
17529                                              if (((word >> 23) & 0x1) == 0)
17530                                                {
17531                                                  /* 33222222222211111111110000000000
17532                                                     10987654321098765432109876543210
17533                                                     xx01110100xxxxxx0000xxxxxxxxxxxx
17534                                                     cpyp.  */
17535                                                  return 2562;
17536                                                }
17537                                              else
17538                                                {
17539                                                  /* 33222222222211111111110000000000
17540                                                     10987654321098765432109876543210
17541                                                     xx01110110xxxxxx0000xxxxxxxxxxxx
17542                                                     cpye.  */
17543                                                  return 2564;
17544                                                }
17545                                            }
17546                                          else
17547                                            {
17548                                              if (((word >> 23) & 0x1) == 0)
17549                                                {
17550                                                  /* 33222222222211111111110000000000
17551                                                     10987654321098765432109876543210
17552                                                     xx01110100xxxxxx1000xxxxxxxxxxxx
17553                                                     cpyprn.  */
17554                                                  return 2568;
17555                                                }
17556                                              else
17557                                                {
17558                                                  /* 33222222222211111111110000000000
17559                                                     10987654321098765432109876543210
17560                                                     xx01110110xxxxxx1000xxxxxxxxxxxx
17561                                                     cpyern.  */
17562                                                  return 2570;
17563                                                }
17564                                            }
17565                                        }
17566                                      else
17567                                        {
17568                                          if (((word >> 15) & 0x1) == 0)
17569                                            {
17570                                              if (((word >> 23) & 0x1) == 0)
17571                                                {
17572                                                  /* 33222222222211111111110000000000
17573                                                     10987654321098765432109876543210
17574                                                     xx01110100xxxxxx0100xxxxxxxxxxxx
17575                                                     cpypwn.  */
17576                                                  return 2565;
17577                                                }
17578                                              else
17579                                                {
17580                                                  /* 33222222222211111111110000000000
17581                                                     10987654321098765432109876543210
17582                                                     xx01110110xxxxxx0100xxxxxxxxxxxx
17583                                                     cpyewn.  */
17584                                                  return 2567;
17585                                                }
17586                                            }
17587                                          else
17588                                            {
17589                                              if (((word >> 23) & 0x1) == 0)
17590                                                {
17591                                                  /* 33222222222211111111110000000000
17592                                                     10987654321098765432109876543210
17593                                                     xx01110100xxxxxx1100xxxxxxxxxxxx
17594                                                     cpypn.  */
17595                                                  return 2571;
17596                                                }
17597                                              else
17598                                                {
17599                                                  /* 33222222222211111111110000000000
17600                                                     10987654321098765432109876543210
17601                                                     xx01110110xxxxxx1100xxxxxxxxxxxx
17602                                                     cpyen.  */
17603                                                  return 2573;
17604                                                }
17605                                            }
17606                                        }
17607                                    }
17608                                  else
17609                                    {
17610                                      if (((word >> 14) & 0x1) == 0)
17611                                        {
17612                                          if (((word >> 15) & 0x1) == 0)
17613                                            {
17614                                              if (((word >> 23) & 0x1) == 0)
17615                                                {
17616                                                  /* 33222222222211111111110000000000
17617                                                     10987654321098765432109876543210
17618                                                     xx01110100xxxxxx0010xxxxxxxxxxxx
17619                                                     cpyprt.  */
17620                                                  return 2586;
17621                                                }
17622                                              else
17623                                                {
17624                                                  /* 33222222222211111111110000000000
17625                                                     10987654321098765432109876543210
17626                                                     xx01110110xxxxxx0010xxxxxxxxxxxx
17627                                                     cpyert.  */
17628                                                  return 2588;
17629                                                }
17630                                            }
17631                                          else
17632                                            {
17633                                              if (((word >> 23) & 0x1) == 0)
17634                                                {
17635                                                  /* 33222222222211111111110000000000
17636                                                     10987654321098765432109876543210
17637                                                     xx01110100xxxxxx1010xxxxxxxxxxxx
17638                                                     cpyprtrn.  */
17639                                                  return 2592;
17640                                                }
17641                                              else
17642                                                {
17643                                                  /* 33222222222211111111110000000000
17644                                                     10987654321098765432109876543210
17645                                                     xx01110110xxxxxx1010xxxxxxxxxxxx
17646                                                     cpyertrn.  */
17647                                                  return 2594;
17648                                                }
17649                                            }
17650                                        }
17651                                      else
17652                                        {
17653                                          if (((word >> 15) & 0x1) == 0)
17654                                            {
17655                                              if (((word >> 23) & 0x1) == 0)
17656                                                {
17657                                                  /* 33222222222211111111110000000000
17658                                                     10987654321098765432109876543210
17659                                                     xx01110100xxxxxx0110xxxxxxxxxxxx
17660                                                     cpyprtwn.  */
17661                                                  return 2589;
17662                                                }
17663                                              else
17664                                                {
17665                                                  /* 33222222222211111111110000000000
17666                                                     10987654321098765432109876543210
17667                                                     xx01110110xxxxxx0110xxxxxxxxxxxx
17668                                                     cpyertwn.  */
17669                                                  return 2591;
17670                                                }
17671                                            }
17672                                          else
17673                                            {
17674                                              if (((word >> 23) & 0x1) == 0)
17675                                                {
17676                                                  /* 33222222222211111111110000000000
17677                                                     10987654321098765432109876543210
17678                                                     xx01110100xxxxxx1110xxxxxxxxxxxx
17679                                                     cpyprtn.  */
17680                                                  return 2595;
17681                                                }
17682                                              else
17683                                                {
17684                                                  /* 33222222222211111111110000000000
17685                                                     10987654321098765432109876543210
17686                                                     xx01110110xxxxxx1110xxxxxxxxxxxx
17687                                                     cpyertn.  */
17688                                                  return 2597;
17689                                                }
17690                                            }
17691                                        }
17692                                    }
17693                                }
17694                              else
17695                                {
17696                                  if (((word >> 13) & 0x1) == 0)
17697                                    {
17698                                      if (((word >> 14) & 0x1) == 0)
17699                                        {
17700                                          if (((word >> 15) & 0x1) == 0)
17701                                            {
17702                                              if (((word >> 23) & 0x1) == 0)
17703                                                {
17704                                                  /* 33222222222211111111110000000000
17705                                                     10987654321098765432109876543210
17706                                                     xx01110100xxxxxx0001xxxxxxxxxxxx
17707                                                     cpypwt.  */
17708                                                  return 2574;
17709                                                }
17710                                              else
17711                                                {
17712                                                  /* 33222222222211111111110000000000
17713                                                     10987654321098765432109876543210
17714                                                     xx01110110xxxxxx0001xxxxxxxxxxxx
17715                                                     cpyewt.  */
17716                                                  return 2576;
17717                                                }
17718                                            }
17719                                          else
17720                                            {
17721                                              if (((word >> 23) & 0x1) == 0)
17722                                                {
17723                                                  /* 33222222222211111111110000000000
17724                                                     10987654321098765432109876543210
17725                                                     xx01110100xxxxxx1001xxxxxxxxxxxx
17726                                                     cpypwtrn.  */
17727                                                  return 2580;
17728                                                }
17729                                              else
17730                                                {
17731                                                  /* 33222222222211111111110000000000
17732                                                     10987654321098765432109876543210
17733                                                     xx01110110xxxxxx1001xxxxxxxxxxxx
17734                                                     cpyewtrn.  */
17735                                                  return 2582;
17736                                                }
17737                                            }
17738                                        }
17739                                      else
17740                                        {
17741                                          if (((word >> 15) & 0x1) == 0)
17742                                            {
17743                                              if (((word >> 23) & 0x1) == 0)
17744                                                {
17745                                                  /* 33222222222211111111110000000000
17746                                                     10987654321098765432109876543210
17747                                                     xx01110100xxxxxx0101xxxxxxxxxxxx
17748                                                     cpypwtwn.  */
17749                                                  return 2577;
17750                                                }
17751                                              else
17752                                                {
17753                                                  /* 33222222222211111111110000000000
17754                                                     10987654321098765432109876543210
17755                                                     xx01110110xxxxxx0101xxxxxxxxxxxx
17756                                                     cpyewtwn.  */
17757                                                  return 2579;
17758                                                }
17759                                            }
17760                                          else
17761                                            {
17762                                              if (((word >> 23) & 0x1) == 0)
17763                                                {
17764                                                  /* 33222222222211111111110000000000
17765                                                     10987654321098765432109876543210
17766                                                     xx01110100xxxxxx1101xxxxxxxxxxxx
17767                                                     cpypwtn.  */
17768                                                  return 2583;
17769                                                }
17770                                              else
17771                                                {
17772                                                  /* 33222222222211111111110000000000
17773                                                     10987654321098765432109876543210
17774                                                     xx01110110xxxxxx1101xxxxxxxxxxxx
17775                                                     cpyewtn.  */
17776                                                  return 2585;
17777                                                }
17778                                            }
17779                                        }
17780                                    }
17781                                  else
17782                                    {
17783                                      if (((word >> 14) & 0x1) == 0)
17784                                        {
17785                                          if (((word >> 15) & 0x1) == 0)
17786                                            {
17787                                              if (((word >> 23) & 0x1) == 0)
17788                                                {
17789                                                  /* 33222222222211111111110000000000
17790                                                     10987654321098765432109876543210
17791                                                     xx01110100xxxxxx0011xxxxxxxxxxxx
17792                                                     cpypt.  */
17793                                                  return 2598;
17794                                                }
17795                                              else
17796                                                {
17797                                                  /* 33222222222211111111110000000000
17798                                                     10987654321098765432109876543210
17799                                                     xx01110110xxxxxx0011xxxxxxxxxxxx
17800                                                     cpyet.  */
17801                                                  return 2600;
17802                                                }
17803                                            }
17804                                          else
17805                                            {
17806                                              if (((word >> 23) & 0x1) == 0)
17807                                                {
17808                                                  /* 33222222222211111111110000000000
17809                                                     10987654321098765432109876543210
17810                                                     xx01110100xxxxxx1011xxxxxxxxxxxx
17811                                                     cpyptrn.  */
17812                                                  return 2604;
17813                                                }
17814                                              else
17815                                                {
17816                                                  /* 33222222222211111111110000000000
17817                                                     10987654321098765432109876543210
17818                                                     xx01110110xxxxxx1011xxxxxxxxxxxx
17819                                                     cpyetrn.  */
17820                                                  return 2606;
17821                                                }
17822                                            }
17823                                        }
17824                                      else
17825                                        {
17826                                          if (((word >> 15) & 0x1) == 0)
17827                                            {
17828                                              if (((word >> 23) & 0x1) == 0)
17829                                                {
17830                                                  /* 33222222222211111111110000000000
17831                                                     10987654321098765432109876543210
17832                                                     xx01110100xxxxxx0111xxxxxxxxxxxx
17833                                                     cpyptwn.  */
17834                                                  return 2601;
17835                                                }
17836                                              else
17837                                                {
17838                                                  /* 33222222222211111111110000000000
17839                                                     10987654321098765432109876543210
17840                                                     xx01110110xxxxxx0111xxxxxxxxxxxx
17841                                                     cpyetwn.  */
17842                                                  return 2603;
17843                                                }
17844                                            }
17845                                          else
17846                                            {
17847                                              if (((word >> 23) & 0x1) == 0)
17848                                                {
17849                                                  /* 33222222222211111111110000000000
17850                                                     10987654321098765432109876543210
17851                                                     xx01110100xxxxxx1111xxxxxxxxxxxx
17852                                                     cpyptn.  */
17853                                                  return 2607;
17854                                                }
17855                                              else
17856                                                {
17857                                                  /* 33222222222211111111110000000000
17858                                                     10987654321098765432109876543210
17859                                                     xx01110110xxxxxx1111xxxxxxxxxxxx
17860                                                     cpyetn.  */
17861                                                  return 2609;
17862                                                }
17863                                            }
17864                                        }
17865                                    }
17866                                }
17867                            }
17868                          else
17869                            {
17870                              /* 33222222222211111111110000000000
17871                                 10987654321098765432109876543210
17872                                 xx111101x0xxxxxxxxxxxxxxxxxxxxxx
17873                                 str.  */
17874                              return 892;
17875                            }
17876                        }
17877                      else
17878                        {
17879                          if (((word >> 29) & 0x1) == 0)
17880                            {
17881                              if (((word >> 12) & 0x1) == 0)
17882                                {
17883                                  if (((word >> 13) & 0x1) == 0)
17884                                    {
17885                                      if (((word >> 14) & 0x1) == 0)
17886                                        {
17887                                          if (((word >> 15) & 0x1) == 0)
17888                                            {
17889                                              if (((word >> 23) & 0x1) == 0)
17890                                                {
17891                                                  /* 33222222222211111111110000000000
17892                                                     10987654321098765432109876543210
17893                                                     xx01110101xxxxxx0000xxxxxxxxxxxx
17894                                                     cpym.  */
17895                                                  return 2563;
17896                                                }
17897                                              else
17898                                                {
17899                                                  /* 33222222222211111111110000000000
17900                                                     10987654321098765432109876543210
17901                                                     xx01110111xxxxxx0000xxxxxxxxxxxx
17902                                                     setgp.  */
17903                                                  return 2622;
17904                                                }
17905                                            }
17906                                          else
17907                                            {
17908                                              if (((word >> 23) & 0x1) == 0)
17909                                                {
17910                                                  /* 33222222222211111111110000000000
17911                                                     10987654321098765432109876543210
17912                                                     xx01110101xxxxxx1000xxxxxxxxxxxx
17913                                                     cpymrn.  */
17914                                                  return 2569;
17915                                                }
17916                                              else
17917                                                {
17918                                                  /* 33222222222211111111110000000000
17919                                                     10987654321098765432109876543210
17920                                                     xx01110111xxxxxx1000xxxxxxxxxxxx
17921                                                     setge.  */
17922                                                  return 2624;
17923                                                }
17924                                            }
17925                                        }
17926                                      else
17927                                        {
17928                                          if (((word >> 15) & 0x1) == 0)
17929                                            {
17930                                              if (((word >> 23) & 0x1) == 0)
17931                                                {
17932                                                  /* 33222222222211111111110000000000
17933                                                     10987654321098765432109876543210
17934                                                     xx01110101xxxxxx0100xxxxxxxxxxxx
17935                                                     cpymwn.  */
17936                                                  return 2566;
17937                                                }
17938                                              else
17939                                                {
17940                                                  /* 33222222222211111111110000000000
17941                                                     10987654321098765432109876543210
17942                                                     xx01110111xxxxxx0100xxxxxxxxxxxx
17943                                                     setgm.  */
17944                                                  return 2623;
17945                                                }
17946                                            }
17947                                          else
17948                                            {
17949                                              /* 33222222222211111111110000000000
17950                                                 10987654321098765432109876543210
17951                                                 xx011101x1xxxxxx1100xxxxxxxxxxxx
17952                                                 cpymn.  */
17953                                              return 2572;
17954                                            }
17955                                        }
17956                                    }
17957                                  else
17958                                    {
17959                                      if (((word >> 14) & 0x1) == 0)
17960                                        {
17961                                          if (((word >> 15) & 0x1) == 0)
17962                                            {
17963                                              if (((word >> 23) & 0x1) == 0)
17964                                                {
17965                                                  /* 33222222222211111111110000000000
17966                                                     10987654321098765432109876543210
17967                                                     xx01110101xxxxxx0010xxxxxxxxxxxx
17968                                                     cpymrt.  */
17969                                                  return 2587;
17970                                                }
17971                                              else
17972                                                {
17973                                                  /* 33222222222211111111110000000000
17974                                                     10987654321098765432109876543210
17975                                                     xx01110111xxxxxx0010xxxxxxxxxxxx
17976                                                     setgpn.  */
17977                                                  return 2628;
17978                                                }
17979                                            }
17980                                          else
17981                                            {
17982                                              if (((word >> 23) & 0x1) == 0)
17983                                                {
17984                                                  /* 33222222222211111111110000000000
17985                                                     10987654321098765432109876543210
17986                                                     xx01110101xxxxxx1010xxxxxxxxxxxx
17987                                                     cpymrtrn.  */
17988                                                  return 2593;
17989                                                }
17990                                              else
17991                                                {
17992                                                  /* 33222222222211111111110000000000
17993                                                     10987654321098765432109876543210
17994                                                     xx01110111xxxxxx1010xxxxxxxxxxxx
17995                                                     setgen.  */
17996                                                  return 2630;
17997                                                }
17998                                            }
17999                                        }
18000                                      else
18001                                        {
18002                                          if (((word >> 15) & 0x1) == 0)
18003                                            {
18004                                              if (((word >> 23) & 0x1) == 0)
18005                                                {
18006                                                  /* 33222222222211111111110000000000
18007                                                     10987654321098765432109876543210
18008                                                     xx01110101xxxxxx0110xxxxxxxxxxxx
18009                                                     cpymrtwn.  */
18010                                                  return 2590;
18011                                                }
18012                                              else
18013                                                {
18014                                                  /* 33222222222211111111110000000000
18015                                                     10987654321098765432109876543210
18016                                                     xx01110111xxxxxx0110xxxxxxxxxxxx
18017                                                     setgmn.  */
18018                                                  return 2629;
18019                                                }
18020                                            }
18021                                          else
18022                                            {
18023                                              /* 33222222222211111111110000000000
18024                                                 10987654321098765432109876543210
18025                                                 xx011101x1xxxxxx1110xxxxxxxxxxxx
18026                                                 cpymrtn.  */
18027                                              return 2596;
18028                                            }
18029                                        }
18030                                    }
18031                                }
18032                              else
18033                                {
18034                                  if (((word >> 13) & 0x1) == 0)
18035                                    {
18036                                      if (((word >> 14) & 0x1) == 0)
18037                                        {
18038                                          if (((word >> 15) & 0x1) == 0)
18039                                            {
18040                                              if (((word >> 23) & 0x1) == 0)
18041                                                {
18042                                                  /* 33222222222211111111110000000000
18043                                                     10987654321098765432109876543210
18044                                                     xx01110101xxxxxx0001xxxxxxxxxxxx
18045                                                     cpymwt.  */
18046                                                  return 2575;
18047                                                }
18048                                              else
18049                                                {
18050                                                  /* 33222222222211111111110000000000
18051                                                     10987654321098765432109876543210
18052                                                     xx01110111xxxxxx0001xxxxxxxxxxxx
18053                                                     setgpt.  */
18054                                                  return 2625;
18055                                                }
18056                                            }
18057                                          else
18058                                            {
18059                                              if (((word >> 23) & 0x1) == 0)
18060                                                {
18061                                                  /* 33222222222211111111110000000000
18062                                                     10987654321098765432109876543210
18063                                                     xx01110101xxxxxx1001xxxxxxxxxxxx
18064                                                     cpymwtrn.  */
18065                                                  return 2581;
18066                                                }
18067                                              else
18068                                                {
18069                                                  /* 33222222222211111111110000000000
18070                                                     10987654321098765432109876543210
18071                                                     xx01110111xxxxxx1001xxxxxxxxxxxx
18072                                                     setget.  */
18073                                                  return 2627;
18074                                                }
18075                                            }
18076                                        }
18077                                      else
18078                                        {
18079                                          if (((word >> 15) & 0x1) == 0)
18080                                            {
18081                                              if (((word >> 23) & 0x1) == 0)
18082                                                {
18083                                                  /* 33222222222211111111110000000000
18084                                                     10987654321098765432109876543210
18085                                                     xx01110101xxxxxx0101xxxxxxxxxxxx
18086                                                     cpymwtwn.  */
18087                                                  return 2578;
18088                                                }
18089                                              else
18090                                                {
18091                                                  /* 33222222222211111111110000000000
18092                                                     10987654321098765432109876543210
18093                                                     xx01110111xxxxxx0101xxxxxxxxxxxx
18094                                                     setgmt.  */
18095                                                  return 2626;
18096                                                }
18097                                            }
18098                                          else
18099                                            {
18100                                              /* 33222222222211111111110000000000
18101                                                 10987654321098765432109876543210
18102                                                 xx011101x1xxxxxx1101xxxxxxxxxxxx
18103                                                 cpymwtn.  */
18104                                              return 2584;
18105                                            }
18106                                        }
18107                                    }
18108                                  else
18109                                    {
18110                                      if (((word >> 14) & 0x1) == 0)
18111                                        {
18112                                          if (((word >> 15) & 0x1) == 0)
18113                                            {
18114                                              if (((word >> 23) & 0x1) == 0)
18115                                                {
18116                                                  /* 33222222222211111111110000000000
18117                                                     10987654321098765432109876543210
18118                                                     xx01110101xxxxxx0011xxxxxxxxxxxx
18119                                                     cpymt.  */
18120                                                  return 2599;
18121                                                }
18122                                              else
18123                                                {
18124                                                  /* 33222222222211111111110000000000
18125                                                     10987654321098765432109876543210
18126                                                     xx01110111xxxxxx0011xxxxxxxxxxxx
18127                                                     setgptn.  */
18128                                                  return 2631;
18129                                                }
18130                                            }
18131                                          else
18132                                            {
18133                                              if (((word >> 23) & 0x1) == 0)
18134                                                {
18135                                                  /* 33222222222211111111110000000000
18136                                                     10987654321098765432109876543210
18137                                                     xx01110101xxxxxx1011xxxxxxxxxxxx
18138                                                     cpymtrn.  */
18139                                                  return 2605;
18140                                                }
18141                                              else
18142                                                {
18143                                                  /* 33222222222211111111110000000000
18144                                                     10987654321098765432109876543210
18145                                                     xx01110111xxxxxx1011xxxxxxxxxxxx
18146                                                     setgetn.  */
18147                                                  return 2633;
18148                                                }
18149                                            }
18150                                        }
18151                                      else
18152                                        {
18153                                          if (((word >> 15) & 0x1) == 0)
18154                                            {
18155                                              if (((word >> 23) & 0x1) == 0)
18156                                                {
18157                                                  /* 33222222222211111111110000000000
18158                                                     10987654321098765432109876543210
18159                                                     xx01110101xxxxxx0111xxxxxxxxxxxx
18160                                                     cpymtwn.  */
18161                                                  return 2602;
18162                                                }
18163                                              else
18164                                                {
18165                                                  /* 33222222222211111111110000000000
18166                                                     10987654321098765432109876543210
18167                                                     xx01110111xxxxxx0111xxxxxxxxxxxx
18168                                                     setgmtn.  */
18169                                                  return 2632;
18170                                                }
18171                                            }
18172                                          else
18173                                            {
18174                                              /* 33222222222211111111110000000000
18175                                                 10987654321098765432109876543210
18176                                                 xx011101x1xxxxxx1111xxxxxxxxxxxx
18177                                                 cpymtn.  */
18178                                              return 2608;
18179                                            }
18180                                        }
18181                                    }
18182                                }
18183                            }
18184                          else
18185                            {
18186                              /* 33222222222211111111110000000000
18187                                 10987654321098765432109876543210
18188                                 xx111101x1xxxxxxxxxxxxxxxxxxxxxx
18189                                 ldr.  */
18190                              return 893;
18191                            }
18192                        }
18193                    }
18194                }
18195            }
18196          else
18197            {
18198              if (((word >> 24) & 0x1) == 0)
18199                {
18200                  if (((word >> 21) & 0x1) == 0)
18201                    {
18202                      if (((word >> 28) & 0x1) == 0)
18203                        {
18204                          if (((word >> 29) & 0x1) == 0)
18205                            {
18206                              if (((word >> 31) & 0x1) == 0)
18207                                {
18208                                  if (((word >> 10) & 0x1) == 0)
18209                                    {
18210                                      if (((word >> 11) & 0x1) == 0)
18211                                        {
18212                                          if (((word >> 12) & 0x1) == 0)
18213                                            {
18214                                              /* 33222222222211111111110000000000
18215                                                 10987654321098765432109876543210
18216                                                 0x001110xx0xxxxxxxx000xxxxxxxxxx
18217                                                 tbl.  */
18218                                              return 420;
18219                                            }
18220                                          else
18221                                            {
18222                                              /* 33222222222211111111110000000000
18223                                                 10987654321098765432109876543210
18224                                                 0x001110xx0xxxxxxxx100xxxxxxxxxx
18225                                                 tbx.  */
18226                                              return 421;
18227                                            }
18228                                        }
18229                                      else
18230                                        {
18231                                          if (((word >> 12) & 0x1) == 0)
18232                                            {
18233                                              if (((word >> 14) & 0x1) == 0)
18234                                                {
18235                                                  /* 33222222222211111111110000000000
18236                                                     10987654321098765432109876543210
18237                                                     0x001110xx0xxxxxx0x010xxxxxxxxxx
18238                                                     trn1.  */
18239                                                  return 263;
18240                                                }
18241                                              else
18242                                                {
18243                                                  /* 33222222222211111111110000000000
18244                                                     10987654321098765432109876543210
18245                                                     0x001110xx0xxxxxx1x010xxxxxxxxxx
18246                                                     trn2.  */
18247                                                  return 266;
18248                                                }
18249                                            }
18250                                          else
18251                                            {
18252                                              if (((word >> 13) & 0x1) == 0)
18253                                                {
18254                                                  if (((word >> 14) & 0x1) == 0)
18255                                                    {
18256                                                      /* 33222222222211111111110000000000
18257                                                         10987654321098765432109876543210
18258                                                         0x001110xx0xxxxxx00110xxxxxxxxxx
18259                                                         uzp1.  */
18260                                                      return 262;
18261                                                    }
18262                                                  else
18263                                                    {
18264                                                      /* 33222222222211111111110000000000
18265                                                         10987654321098765432109876543210
18266                                                         0x001110xx0xxxxxx10110xxxxxxxxxx
18267                                                         uzp2.  */
18268                                                      return 265;
18269                                                    }
18270                                                }
18271                                              else
18272                                                {
18273                                                  if (((word >> 14) & 0x1) == 0)
18274                                                    {
18275                                                      /* 33222222222211111111110000000000
18276                                                         10987654321098765432109876543210
18277                                                         0x001110xx0xxxxxx01110xxxxxxxxxx
18278                                                         zip1.  */
18279                                                      return 264;
18280                                                    }
18281                                                  else
18282                                                    {
18283                                                      /* 33222222222211111111110000000000
18284                                                         10987654321098765432109876543210
18285                                                         0x001110xx0xxxxxx11110xxxxxxxxxx
18286                                                         zip2.  */
18287                                                      return 267;
18288                                                    }
18289                                                }
18290                                            }
18291                                        }
18292                                    }
18293                                  else
18294                                    {
18295                                      if (((word >> 11) & 0x1) == 0)
18296                                        {
18297                                          if (((word >> 12) & 0x1) == 0)
18298                                            {
18299                                              if (((word >> 13) & 0x1) == 0)
18300                                                {
18301                                                  if (((word >> 22) & 0x1) == 0)
18302                                                    {
18303                                                      /* 33222222222211111111110000000000
18304                                                         10987654321098765432109876543210
18305                                                         0x001110x00xxxxxxx0001xxxxxxxxxx
18306                                                         dup.  */
18307                                                      return 149;
18308                                                    }
18309                                                  else
18310                                                    {
18311                                                      if (((word >> 23) & 0x1) == 0)
18312                                                        {
18313                                                          /* 33222222222211111111110000000000
18314                                                             10987654321098765432109876543210
18315                                                             0x001110010xxxxxxx0001xxxxxxxxxx
18316                                                             fmaxnm.  */
18317                                                          return 292;
18318                                                        }
18319                                                      else
18320                                                        {
18321                                                          /* 33222222222211111111110000000000
18322                                                             10987654321098765432109876543210
18323                                                             0x001110110xxxxxxx0001xxxxxxxxxx
18324                                                             fminnm.  */
18325                                                          return 308;
18326                                                        }
18327                                                    }
18328                                                }
18329                                              else
18330                                                {
18331                                                  if (((word >> 15) & 0x1) == 0)
18332                                                    {
18333                                                      /* 33222222222211111111110000000000
18334                                                         10987654321098765432109876543210
18335                                                         0x001110xx0xxxxx0x1001xxxxxxxxxx
18336                                                         fcmeq.  */
18337                                                      return 300;
18338                                                    }
18339                                                  else
18340                                                    {
18341                                                      /* 33222222222211111111110000000000
18342                                                         10987654321098765432109876543210
18343                                                         0x001110xx0xxxxx1x1001xxxxxxxxxx
18344                                                         smmla.  */
18345                                                      return 2489;
18346                                                    }
18347                                                }
18348                                            }
18349                                          else
18350                                            {
18351                                              if (((word >> 13) & 0x1) == 0)
18352                                                {
18353                                                  if (((word >> 15) & 0x1) == 0)
18354                                                    {
18355                                                      if (((word >> 23) & 0x1) == 0)
18356                                                        {
18357                                                          /* 33222222222211111111110000000000
18358                                                             10987654321098765432109876543210
18359                                                             0x0011100x0xxxxx0x0101xxxxxxxxxx
18360                                                             fadd.  */
18361                                                          return 296;
18362                                                        }
18363                                                      else
18364                                                        {
18365                                                          /* 33222222222211111111110000000000
18366                                                             10987654321098765432109876543210
18367                                                             0x0011101x0xxxxx0x0101xxxxxxxxxx
18368                                                             fsub.  */
18369                                                          return 312;
18370                                                        }
18371                                                    }
18372                                                  else
18373                                                    {
18374                                                      /* 33222222222211111111110000000000
18375                                                         10987654321098765432109876543210
18376                                                         0x001110xx0xxxxx1x0101xxxxxxxxxx
18377                                                         sdot.  */
18378                                                      return 2415;
18379                                                    }
18380                                                }
18381                                              else
18382                                                {
18383                                                  if (((word >> 23) & 0x1) == 0)
18384                                                    {
18385                                                      /* 33222222222211111111110000000000
18386                                                         10987654321098765432109876543210
18387                                                         0x0011100x0xxxxxxx1101xxxxxxxxxx
18388                                                         fmax.  */
18389                                                      return 302;
18390                                                    }
18391                                                  else
18392                                                    {
18393                                                      /* 33222222222211111111110000000000
18394                                                         10987654321098765432109876543210
18395                                                         0x0011101x0xxxxxxx1101xxxxxxxxxx
18396                                                         fmin.  */
18397                                                      return 314;
18398                                                    }
18399                                                }
18400                                            }
18401                                        }
18402                                      else
18403                                        {
18404                                          if (((word >> 12) & 0x1) == 0)
18405                                            {
18406                                              if (((word >> 13) & 0x1) == 0)
18407                                                {
18408                                                  if (((word >> 22) & 0x1) == 0)
18409                                                    {
18410                                                      /* 33222222222211111111110000000000
18411                                                         10987654321098765432109876543210
18412                                                         0x001110x00xxxxxxx0011xxxxxxxxxx
18413                                                         dup.  */
18414                                                      return 150;
18415                                                    }
18416                                                  else
18417                                                    {
18418                                                      if (((word >> 23) & 0x1) == 0)
18419                                                        {
18420                                                          /* 33222222222211111111110000000000
18421                                                             10987654321098765432109876543210
18422                                                             0x001110010xxxxxxx0011xxxxxxxxxx
18423                                                             fmla.  */
18424                                                          return 294;
18425                                                        }
18426                                                      else
18427                                                        {
18428                                                          /* 33222222222211111111110000000000
18429                                                             10987654321098765432109876543210
18430                                                             0x001110110xxxxxxx0011xxxxxxxxxx
18431                                                             fmls.  */
18432                                                          return 310;
18433                                                        }
18434                                                    }
18435                                                }
18436                                              else
18437                                                {
18438                                                  if (((word >> 15) & 0x1) == 0)
18439                                                    {
18440                                                      /* 33222222222211111111110000000000
18441                                                         10987654321098765432109876543210
18442                                                         0x001110xx0xxxxx0x1011xxxxxxxxxx
18443                                                         smov.  */
18444                                                      return 151;
18445                                                    }
18446                                                  else
18447                                                    {
18448                                                      /* 33222222222211111111110000000000
18449                                                         10987654321098765432109876543210
18450                                                         0x001110xx0xxxxx1x1011xxxxxxxxxx
18451                                                         usmmla.  */
18452                                                      return 2491;
18453                                                    }
18454                                                }
18455                                            }
18456                                          else
18457                                            {
18458                                              if (((word >> 13) & 0x1) == 0)
18459                                                {
18460                                                  if (((word >> 15) & 0x1) == 0)
18461                                                    {
18462                                                      if (((word >> 22) & 0x1) == 0)
18463                                                        {
18464                                                          /* 33222222222211111111110000000000
18465                                                             10987654321098765432109876543210
18466                                                             0x001110x00xxxxx0x0111xxxxxxxxxx
18467                                                             ins.  */
18468                                                          return 154;
18469                                                        }
18470                                                      else
18471                                                        {
18472                                                          /* 33222222222211111111110000000000
18473                                                             10987654321098765432109876543210
18474                                                             0x001110x10xxxxx0x0111xxxxxxxxxx
18475                                                             fmulx.  */
18476                                                          return 298;
18477                                                        }
18478                                                    }
18479                                                  else
18480                                                    {
18481                                                      /* 33222222222211111111110000000000
18482                                                         10987654321098765432109876543210
18483                                                         0x001110xx0xxxxx1x0111xxxxxxxxxx
18484                                                         usdot.  */
18485                                                      return 2492;
18486                                                    }
18487                                                }
18488                                              else
18489                                                {
18490                                                  if (((word >> 22) & 0x1) == 0)
18491                                                    {
18492                                                      /* 33222222222211111111110000000000
18493                                                         10987654321098765432109876543210
18494                                                         0x001110x00xxxxxxx1111xxxxxxxxxx
18495                                                         umov.  */
18496                                                      return 152;
18497                                                    }
18498                                                  else
18499                                                    {
18500                                                      if (((word >> 23) & 0x1) == 0)
18501                                                        {
18502                                                          /* 33222222222211111111110000000000
18503                                                             10987654321098765432109876543210
18504                                                             0x001110010xxxxxxx1111xxxxxxxxxx
18505                                                             frecps.  */
18506                                                          return 304;
18507                                                        }
18508                                                      else
18509                                                        {
18510                                                          /* 33222222222211111111110000000000
18511                                                             10987654321098765432109876543210
18512                                                             0x001110110xxxxxxx1111xxxxxxxxxx
18513                                                             frsqrts.  */
18514                                                          return 316;
18515                                                        }
18516                                                    }
18517                                                }
18518                                            }
18519                                        }
18520                                    }
18521                                }
18522                              else
18523                                {
18524                                  if (((word >> 22) & 0x1) == 0)
18525                                    {
18526                                      if (((word >> 23) & 0x1) == 0)
18527                                        {
18528                                          /* 33222222222211111111110000000000
18529                                             10987654321098765432109876543210
18530                                             1x001110000xxxxxxxxxxxxxxxxxxxxx
18531                                             eor3.  */
18532                                          return 2422;
18533                                        }
18534                                      else
18535                                        {
18536                                          /* 33222222222211111111110000000000
18537                                             10987654321098765432109876543210
18538                                             1x001110100xxxxxxxxxxxxxxxxxxxxx
18539                                             xar.  */
18540                                          return 2424;
18541                                        }
18542                                    }
18543                                  else
18544                                    {
18545                                      if (((word >> 15) & 0x1) == 0)
18546                                        {
18547                                          /* 33222222222211111111110000000000
18548                                             10987654321098765432109876543210
18549                                             1x001110x10xxxxx0xxxxxxxxxxxxxxx
18550                                             sm3ss1.  */
18551                                          return 2426;
18552                                        }
18553                                      else
18554                                        {
18555                                          if (((word >> 10) & 0x1) == 0)
18556                                            {
18557                                              if (((word >> 11) & 0x1) == 0)
18558                                                {
18559                                                  if (((word >> 23) & 0x1) == 0)
18560                                                    {
18561                                                      /* 33222222222211111111110000000000
18562                                                         10987654321098765432109876543210
18563                                                         1x001110010xxxxx1xxx00xxxxxxxxxx
18564                                                         sm3tt1a.  */
18565                                                      return 2427;
18566                                                    }
18567                                                  else
18568                                                    {
18569                                                      /* 33222222222211111111110000000000
18570                                                         10987654321098765432109876543210
18571                                                         1x001110110xxxxx1xxx00xxxxxxxxxx
18572                                                         sha512su0.  */
18573                                                      return 2420;
18574                                                    }
18575                                                }
18576                                              else
18577                                                {
18578                                                  /* 33222222222211111111110000000000
18579                                                     10987654321098765432109876543210
18580                                                     1x001110x10xxxxx1xxx10xxxxxxxxxx
18581                                                     sm3tt2a.  */
18582                                                  return 2429;
18583                                                }
18584                                            }
18585                                          else
18586                                            {
18587                                              if (((word >> 11) & 0x1) == 0)
18588                                                {
18589                                                  if (((word >> 23) & 0x1) == 0)
18590                                                    {
18591                                                      /* 33222222222211111111110000000000
18592                                                         10987654321098765432109876543210
18593                                                         1x001110010xxxxx1xxx01xxxxxxxxxx
18594                                                         sm3tt1b.  */
18595                                                      return 2428;
18596                                                    }
18597                                                  else
18598                                                    {
18599                                                      /* 33222222222211111111110000000000
18600                                                         10987654321098765432109876543210
18601                                                         1x001110110xxxxx1xxx01xxxxxxxxxx
18602                                                         sm4e.  */
18603                                                      return 2433;
18604                                                    }
18605                                                }
18606                                              else
18607                                                {
18608                                                  /* 33222222222211111111110000000000
18609                                                     10987654321098765432109876543210
18610                                                     1x001110x10xxxxx1xxx11xxxxxxxxxx
18611                                                     sm3tt2b.  */
18612                                                  return 2430;
18613                                                }
18614                                            }
18615                                        }
18616                                    }
18617                                }
18618                            }
18619                          else
18620                            {
18621                              if (((word >> 10) & 0x1) == 0)
18622                                {
18623                                  /* 33222222222211111111110000000000
18624                                     10987654321098765432109876543210
18625                                     xx101110xx0xxxxxxxxxx0xxxxxxxxxx
18626                                     ext.  */
18627                                  return 132;
18628                                }
18629                              else
18630                                {
18631                                  if (((word >> 15) & 0x1) == 0)
18632                                    {
18633                                      if (((word >> 22) & 0x1) == 0)
18634                                        {
18635                                          /* 33222222222211111111110000000000
18636                                             10987654321098765432109876543210
18637                                             xx101110x00xxxxx0xxxx1xxxxxxxxxx
18638                                             ins.  */
18639                                          return 156;
18640                                        }
18641                                      else
18642                                        {
18643                                          if (((word >> 11) & 0x1) == 0)
18644                                            {
18645                                              if (((word >> 12) & 0x1) == 0)
18646                                                {
18647                                                  if (((word >> 13) & 0x1) == 0)
18648                                                    {
18649                                                      if (((word >> 23) & 0x1) == 0)
18650                                                        {
18651                                                          /* 33222222222211111111110000000000
18652                                                             10987654321098765432109876543210
18653                                                             xx101110010xxxxx0x0001xxxxxxxxxx
18654                                                             fmaxnmp.  */
18655                                                          return 343;
18656                                                        }
18657                                                      else
18658                                                        {
18659                                                          /* 33222222222211111111110000000000
18660                                                             10987654321098765432109876543210
18661                                                             xx101110110xxxxx0x0001xxxxxxxxxx
18662                                                             fminnmp.  */
18663                                                          return 359;
18664                                                        }
18665                                                    }
18666                                                  else
18667                                                    {
18668                                                      if (((word >> 23) & 0x1) == 0)
18669                                                        {
18670                                                          /* 33222222222211111111110000000000
18671                                                             10987654321098765432109876543210
18672                                                             xx101110010xxxxx0x1001xxxxxxxxxx
18673                                                             fcmge.  */
18674                                                          return 349;
18675                                                        }
18676                                                      else
18677                                                        {
18678                                                          /* 33222222222211111111110000000000
18679                                                             10987654321098765432109876543210
18680                                                             xx101110110xxxxx0x1001xxxxxxxxxx
18681                                                             fcmgt.  */
18682                                                          return 363;
18683                                                        }
18684                                                    }
18685                                                }
18686                                              else
18687                                                {
18688                                                  if (((word >> 13) & 0x1) == 0)
18689                                                    {
18690                                                      if (((word >> 23) & 0x1) == 0)
18691                                                        {
18692                                                          /* 33222222222211111111110000000000
18693                                                             10987654321098765432109876543210
18694                                                             xx101110010xxxxx0x0101xxxxxxxxxx
18695                                                             faddp.  */
18696                                                          return 345;
18697                                                        }
18698                                                      else
18699                                                        {
18700                                                          /* 33222222222211111111110000000000
18701                                                             10987654321098765432109876543210
18702                                                             xx101110110xxxxx0x0101xxxxxxxxxx
18703                                                             fabd.  */
18704                                                          return 361;
18705                                                        }
18706                                                    }
18707                                                  else
18708                                                    {
18709                                                      if (((word >> 23) & 0x1) == 0)
18710                                                        {
18711                                                          /* 33222222222211111111110000000000
18712                                                             10987654321098765432109876543210
18713                                                             xx101110010xxxxx0x1101xxxxxxxxxx
18714                                                             fmaxp.  */
18715                                                          return 353;
18716                                                        }
18717                                                      else
18718                                                        {
18719                                                          /* 33222222222211111111110000000000
18720                                                             10987654321098765432109876543210
18721                                                             xx101110110xxxxx0x1101xxxxxxxxxx
18722                                                             fminp.  */
18723                                                          return 367;
18724                                                        }
18725                                                    }
18726                                                }
18727                                            }
18728                                          else
18729                                            {
18730                                              if (((word >> 12) & 0x1) == 0)
18731                                                {
18732                                                  if (((word >> 23) & 0x1) == 0)
18733                                                    {
18734                                                      /* 33222222222211111111110000000000
18735                                                         10987654321098765432109876543210
18736                                                         xx101110010xxxxx0xx011xxxxxxxxxx
18737                                                         facge.  */
18738                                                      return 351;
18739                                                    }
18740                                                  else
18741                                                    {
18742                                                      /* 33222222222211111111110000000000
18743                                                         10987654321098765432109876543210
18744                                                         xx101110110xxxxx0xx011xxxxxxxxxx
18745                                                         facgt.  */
18746                                                      return 365;
18747                                                    }
18748                                                }
18749                                              else
18750                                                {
18751                                                  if (((word >> 13) & 0x1) == 0)
18752                                                    {
18753                                                      /* 33222222222211111111110000000000
18754                                                         10987654321098765432109876543210
18755                                                         xx101110x10xxxxx0x0111xxxxxxxxxx
18756                                                         fmul.  */
18757                                                      return 347;
18758                                                    }
18759                                                  else
18760                                                    {
18761                                                      /* 33222222222211111111110000000000
18762                                                         10987654321098765432109876543210
18763                                                         xx101110x10xxxxx0x1111xxxxxxxxxx
18764                                                         fdiv.  */
18765                                                      return 355;
18766                                                    }
18767                                                }
18768                                            }
18769                                        }
18770                                    }
18771                                  else
18772                                    {
18773                                      if (((word >> 13) & 0x1) == 0)
18774                                        {
18775                                          if (((word >> 14) & 0x1) == 0)
18776                                            {
18777                                              if (((word >> 11) & 0x1) == 0)
18778                                                {
18779                                                  if (((word >> 12) & 0x1) == 0)
18780                                                    {
18781                                                      /* 33222222222211111111110000000000
18782                                                         10987654321098765432109876543210
18783                                                         xx101110xx0xxxxx100001xxxxxxxxxx
18784                                                         sqrdmlah.  */
18785                                                      return 370;
18786                                                    }
18787                                                  else
18788                                                    {
18789                                                      /* 33222222222211111111110000000000
18790                                                         10987654321098765432109876543210
18791                                                         xx101110xx0xxxxx100101xxxxxxxxxx
18792                                                         udot.  */
18793                                                      return 2414;
18794                                                    }
18795                                                }
18796                                              else
18797                                                {
18798                                                  /* 33222222222211111111110000000000
18799                                                     10987654321098765432109876543210
18800                                                     xx101110xx0xxxxx100x11xxxxxxxxxx
18801                                                     sqrdmlsh.  */
18802                                                  return 371;
18803                                                }
18804                                            }
18805                                          else
18806                                            {
18807                                              /* 33222222222211111111110000000000
18808                                                 10987654321098765432109876543210
18809                                                 xx101110xx0xxxxx110xx1xxxxxxxxxx
18810                                                 fcmla.  */
18811                                              return 372;
18812                                            }
18813                                        }
18814                                      else
18815                                        {
18816                                          if (((word >> 11) & 0x1) == 0)
18817                                            {
18818                                              if (((word >> 14) & 0x1) == 0)
18819                                                {
18820                                                  /* 33222222222211111111110000000000
18821                                                     10987654321098765432109876543210
18822                                                     xx101110xx0xxxxx101x01xxxxxxxxxx
18823                                                     ummla.  */
18824                                                  return 2490;
18825                                                }
18826                                              else
18827                                                {
18828                                                  /* 33222222222211111111110000000000
18829                                                     10987654321098765432109876543210
18830                                                     xx101110xx0xxxxx111x01xxxxxxxxxx
18831                                                     fcadd.  */
18832                                                  return 373;
18833                                                }
18834                                            }
18835                                          else
18836                                            {
18837                                              if (((word >> 12) & 0x1) == 0)
18838                                                {
18839                                                  /* 33222222222211111111110000000000
18840                                                     10987654321098765432109876543210
18841                                                     xx101110xx0xxxxx1x1011xxxxxxxxxx
18842                                                     bfmmla.  */
18843                                                  return 2506;
18844                                                }
18845                                              else
18846                                                {
18847                                                  if (((word >> 23) & 0x1) == 0)
18848                                                    {
18849                                                      /* 33222222222211111111110000000000
18850                                                         10987654321098765432109876543210
18851                                                         xx1011100x0xxxxx1x1111xxxxxxxxxx
18852                                                         bfdot.  */
18853                                                      return 2504;
18854                                                    }
18855                                                  else
18856                                                    {
18857                                                      if (((word >> 30) & 0x1) == 0)
18858                                                        {
18859                                                          /* 33222222222211111111110000000000
18860                                                             10987654321098765432109876543210
18861                                                             x01011101x0xxxxx1x1111xxxxxxxxxx
18862                                                             bfmlalb.  */
18863                                                          return 2511;
18864                                                        }
18865                                                      else
18866                                                        {
18867                                                          /* 33222222222211111111110000000000
18868                                                             10987654321098765432109876543210
18869                                                             x11011101x0xxxxx1x1111xxxxxxxxxx
18870                                                             bfmlalt.  */
18871                                                          return 2510;
18872                                                        }
18873                                                    }
18874                                                }
18875                                            }
18876                                        }
18877                                    }
18878                                }
18879                            }
18880                        }
18881                      else
18882                        {
18883                          if (((word >> 29) & 0x1) == 0)
18884                            {
18885                              if (((word >> 30) & 0x1) == 0)
18886                                {
18887                                  if (((word >> 16) & 0x1) == 0)
18888                                    {
18889                                      if (((word >> 17) & 0x1) == 0)
18890                                        {
18891                                          /* 33222222222211111111110000000000
18892                                             10987654321098765432109876543210
18893                                             x0011110xx0xxx00xxxxxxxxxxxxxxxx
18894                                             fcvtzs.  */
18895                                          return 764;
18896                                        }
18897                                      else
18898                                        {
18899                                          /* 33222222222211111111110000000000
18900                                             10987654321098765432109876543210
18901                                             x0011110xx0xxx10xxxxxxxxxxxxxxxx
18902                                             scvtf.  */
18903                                          return 760;
18904                                        }
18905                                    }
18906                                  else
18907                                    {
18908                                      if (((word >> 17) & 0x1) == 0)
18909                                        {
18910                                          /* 33222222222211111111110000000000
18911                                             10987654321098765432109876543210
18912                                             x0011110xx0xxx01xxxxxxxxxxxxxxxx
18913                                             fcvtzu.  */
18914                                          return 766;
18915                                        }
18916                                      else
18917                                        {
18918                                          /* 33222222222211111111110000000000
18919                                             10987654321098765432109876543210
18920                                             x0011110xx0xxx11xxxxxxxxxxxxxxxx
18921                                             ucvtf.  */
18922                                          return 762;
18923                                        }
18924                                    }
18925                                }
18926                              else
18927                                {
18928                                  if (((word >> 10) & 0x1) == 0)
18929                                    {
18930                                      if (((word >> 12) & 0x1) == 0)
18931                                        {
18932                                          if (((word >> 13) & 0x1) == 0)
18933                                            {
18934                                              if (((word >> 14) & 0x1) == 0)
18935                                                {
18936                                                  /* 33222222222211111111110000000000
18937                                                     10987654321098765432109876543210
18938                                                     x1011110xx0xxxxxx000x0xxxxxxxxxx
18939                                                     sha1c.  */
18940                                                  return 678;
18941                                                }
18942                                              else
18943                                                {
18944                                                  /* 33222222222211111111110000000000
18945                                                     10987654321098765432109876543210
18946                                                     x1011110xx0xxxxxx100x0xxxxxxxxxx
18947                                                     sha256h.  */
18948                                                  return 682;
18949                                                }
18950                                            }
18951                                          else
18952                                            {
18953                                              if (((word >> 14) & 0x1) == 0)
18954                                                {
18955                                                  /* 33222222222211111111110000000000
18956                                                     10987654321098765432109876543210
18957                                                     x1011110xx0xxxxxx010x0xxxxxxxxxx
18958                                                     sha1m.  */
18959                                                  return 680;
18960                                                }
18961                                              else
18962                                                {
18963                                                  /* 33222222222211111111110000000000
18964                                                     10987654321098765432109876543210
18965                                                     x1011110xx0xxxxxx110x0xxxxxxxxxx
18966                                                     sha256su1.  */
18967                                                  return 684;
18968                                                }
18969                                            }
18970                                        }
18971                                      else
18972                                        {
18973                                          if (((word >> 13) & 0x1) == 0)
18974                                            {
18975                                              if (((word >> 14) & 0x1) == 0)
18976                                                {
18977                                                  /* 33222222222211111111110000000000
18978                                                     10987654321098765432109876543210
18979                                                     x1011110xx0xxxxxx001x0xxxxxxxxxx
18980                                                     sha1p.  */
18981                                                  return 679;
18982                                                }
18983                                              else
18984                                                {
18985                                                  /* 33222222222211111111110000000000
18986                                                     10987654321098765432109876543210
18987                                                     x1011110xx0xxxxxx101x0xxxxxxxxxx
18988                                                     sha256h2.  */
18989                                                  return 683;
18990                                                }
18991                                            }
18992                                          else
18993                                            {
18994                                              /* 33222222222211111111110000000000
18995                                                 10987654321098765432109876543210
18996                                                 x1011110xx0xxxxxxx11x0xxxxxxxxxx
18997                                                 sha1su0.  */
18998                                              return 681;
18999                                            }
19000                                        }
19001                                    }
19002                                  else
19003                                    {
19004                                      if (((word >> 11) & 0x1) == 0)
19005                                        {
19006                                          if (((word >> 13) & 0x1) == 0)
19007                                            {
19008                                              /* 33222222222211111111110000000000
19009                                                 10987654321098765432109876543210
19010                                                 x1011110xx0xxxxxxx0x01xxxxxxxxxx
19011                                                 dup.  */
19012                                              return 535;
19013                                            }
19014                                          else
19015                                            {
19016                                              /* 33222222222211111111110000000000
19017                                                 10987654321098765432109876543210
19018                                                 x1011110xx0xxxxxxx1x01xxxxxxxxxx
19019                                                 fcmeq.  */
19020                                              return 556;
19021                                            }
19022                                        }
19023                                      else
19024                                        {
19025                                          if (((word >> 13) & 0x1) == 0)
19026                                            {
19027                                              /* 33222222222211111111110000000000
19028                                                 10987654321098765432109876543210
19029                                                 x1011110xx0xxxxxxx0x11xxxxxxxxxx
19030                                                 fmulx.  */
19031                                              return 554;
19032                                            }
19033                                          else
19034                                            {
19035                                              if (((word >> 23) & 0x1) == 0)
19036                                                {
19037                                                  /* 33222222222211111111110000000000
19038                                                     10987654321098765432109876543210
19039                                                     x10111100x0xxxxxxx1x11xxxxxxxxxx
19040                                                     frecps.  */
19041                                                  return 558;
19042                                                }
19043                                              else
19044                                                {
19045                                                  /* 33222222222211111111110000000000
19046                                                     10987654321098765432109876543210
19047                                                     x10111101x0xxxxxxx1x11xxxxxxxxxx
19048                                                     frsqrts.  */
19049                                                  return 560;
19050                                                }
19051                                            }
19052                                        }
19053                                    }
19054                                }
19055                            }
19056                          else
19057                            {
19058                              if (((word >> 11) & 0x1) == 0)
19059                                {
19060                                  if (((word >> 12) & 0x1) == 0)
19061                                    {
19062                                      if (((word >> 13) & 0x1) == 0)
19063                                        {
19064                                          /* 33222222222211111111110000000000
19065                                             10987654321098765432109876543210
19066                                             xx111110xx0xxxxxxx000xxxxxxxxxxx
19067                                             sqrdmlah.  */
19068                                          return 588;
19069                                        }
19070                                      else
19071                                        {
19072                                          if (((word >> 23) & 0x1) == 0)
19073                                            {
19074                                              /* 33222222222211111111110000000000
19075                                                 10987654321098765432109876543210
19076                                                 xx1111100x0xxxxxxx100xxxxxxxxxxx
19077                                                 fcmge.  */
19078                                              return 573;
19079                                            }
19080                                          else
19081                                            {
19082                                              /* 33222222222211111111110000000000
19083                                                 10987654321098765432109876543210
19084                                                 xx1111101x0xxxxxxx100xxxxxxxxxxx
19085                                                 fcmgt.  */
19086                                              return 579;
19087                                            }
19088                                        }
19089                                    }
19090                                  else
19091                                    {
19092                                      /* 33222222222211111111110000000000
19093                                         10987654321098765432109876543210
19094                                         xx111110xx0xxxxxxxx10xxxxxxxxxxx
19095                                         fabd.  */
19096                                      return 577;
19097                                    }
19098                                }
19099                              else
19100                                {
19101                                  if (((word >> 13) & 0x1) == 0)
19102                                    {
19103                                      /* 33222222222211111111110000000000
19104                                         10987654321098765432109876543210
19105                                         xx111110xx0xxxxxxx0x1xxxxxxxxxxx
19106                                         sqrdmlsh.  */
19107                                      return 589;
19108                                    }
19109                                  else
19110                                    {
19111                                      if (((word >> 23) & 0x1) == 0)
19112                                        {
19113                                          /* 33222222222211111111110000000000
19114                                             10987654321098765432109876543210
19115                                             xx1111100x0xxxxxxx1x1xxxxxxxxxxx
19116                                             facge.  */
19117                                          return 575;
19118                                        }
19119                                      else
19120                                        {
19121                                          /* 33222222222211111111110000000000
19122                                             10987654321098765432109876543210
19123                                             xx1111101x0xxxxxxx1x1xxxxxxxxxxx
19124                                             facgt.  */
19125                                          return 581;
19126                                        }
19127                                    }
19128                                }
19129                            }
19130                        }
19131                    }
19132                  else
19133                    {
19134                      if (((word >> 28) & 0x1) == 0)
19135                        {
19136                          if (((word >> 15) & 0x1) == 0)
19137                            {
19138                              if (((word >> 29) & 0x1) == 0)
19139                                {
19140                                  if (((word >> 31) & 0x1) == 0)
19141                                    {
19142                                      if (((word >> 10) & 0x1) == 0)
19143                                        {
19144                                          if (((word >> 11) & 0x1) == 0)
19145                                            {
19146                                              if (((word >> 12) & 0x1) == 0)
19147                                                {
19148                                                  if (((word >> 13) & 0x1) == 0)
19149                                                    {
19150                                                      if (((word >> 14) & 0x1) == 0)
19151                                                        {
19152                                                          if (((word >> 30) & 0x1) == 0)
19153                                                            {
19154                                                              /* 33222222222211111111110000000000
19155                                                                 10987654321098765432109876543210
19156                                                                 00001110xx1xxxxx000000xxxxxxxxxx
19157                                                                 saddl.  */
19158                                                              return 44;
19159                                                            }
19160                                                          else
19161                                                            {
19162                                                              /* 33222222222211111111110000000000
19163                                                                 10987654321098765432109876543210
19164                                                                 01001110xx1xxxxx000000xxxxxxxxxx
19165                                                                 saddl2.  */
19166                                                              return 45;
19167                                                            }
19168                                                        }
19169                                                      else
19170                                                        {
19171                                                          if (((word >> 30) & 0x1) == 0)
19172                                                            {
19173                                                              /* 33222222222211111111110000000000
19174                                                                 10987654321098765432109876543210
19175                                                                 00001110xx1xxxxx010000xxxxxxxxxx
19176                                                                 addhn.  */
19177                                                              return 52;
19178                                                            }
19179                                                          else
19180                                                            {
19181                                                              /* 33222222222211111111110000000000
19182                                                                 10987654321098765432109876543210
19183                                                                 01001110xx1xxxxx010000xxxxxxxxxx
19184                                                                 addhn2.  */
19185                                                              return 53;
19186                                                            }
19187                                                        }
19188                                                    }
19189                                                  else
19190                                                    {
19191                                                      if (((word >> 14) & 0x1) == 0)
19192                                                        {
19193                                                          if (((word >> 30) & 0x1) == 0)
19194                                                            {
19195                                                              /* 33222222222211111111110000000000
19196                                                                 10987654321098765432109876543210
19197                                                                 00001110xx1xxxxx001000xxxxxxxxxx
19198                                                                 ssubl.  */
19199                                                              return 48;
19200                                                            }
19201                                                          else
19202                                                            {
19203                                                              /* 33222222222211111111110000000000
19204                                                                 10987654321098765432109876543210
19205                                                                 01001110xx1xxxxx001000xxxxxxxxxx
19206                                                                 ssubl2.  */
19207                                                              return 49;
19208                                                            }
19209                                                        }
19210                                                      else
19211                                                        {
19212                                                          if (((word >> 30) & 0x1) == 0)
19213                                                            {
19214                                                              /* 33222222222211111111110000000000
19215                                                                 10987654321098765432109876543210
19216                                                                 00001110xx1xxxxx011000xxxxxxxxxx
19217                                                                 subhn.  */
19218                                                              return 56;
19219                                                            }
19220                                                          else
19221                                                            {
19222                                                              /* 33222222222211111111110000000000
19223                                                                 10987654321098765432109876543210
19224                                                                 01001110xx1xxxxx011000xxxxxxxxxx
19225                                                                 subhn2.  */
19226                                                              return 57;
19227                                                            }
19228                                                        }
19229                                                    }
19230                                                }
19231                                              else
19232                                                {
19233                                                  if (((word >> 13) & 0x1) == 0)
19234                                                    {
19235                                                      if (((word >> 14) & 0x1) == 0)
19236                                                        {
19237                                                          if (((word >> 30) & 0x1) == 0)
19238                                                            {
19239                                                              /* 33222222222211111111110000000000
19240                                                                 10987654321098765432109876543210
19241                                                                 00001110xx1xxxxx000100xxxxxxxxxx
19242                                                                 saddw.  */
19243                                                              return 46;
19244                                                            }
19245                                                          else
19246                                                            {
19247                                                              /* 33222222222211111111110000000000
19248                                                                 10987654321098765432109876543210
19249                                                                 01001110xx1xxxxx000100xxxxxxxxxx
19250                                                                 saddw2.  */
19251                                                              return 47;
19252                                                            }
19253                                                        }
19254                                                      else
19255                                                        {
19256                                                          if (((word >> 30) & 0x1) == 0)
19257                                                            {
19258                                                              /* 33222222222211111111110000000000
19259                                                                 10987654321098765432109876543210
19260                                                                 00001110xx1xxxxx010100xxxxxxxxxx
19261                                                                 sabal.  */
19262                                                              return 54;
19263                                                            }
19264                                                          else
19265                                                            {
19266                                                              /* 33222222222211111111110000000000
19267                                                                 10987654321098765432109876543210
19268                                                                 01001110xx1xxxxx010100xxxxxxxxxx
19269                                                                 sabal2.  */
19270                                                              return 55;
19271                                                            }
19272                                                        }
19273                                                    }
19274                                                  else
19275                                                    {
19276                                                      if (((word >> 14) & 0x1) == 0)
19277                                                        {
19278                                                          if (((word >> 30) & 0x1) == 0)
19279                                                            {
19280                                                              /* 33222222222211111111110000000000
19281                                                                 10987654321098765432109876543210
19282                                                                 00001110xx1xxxxx001100xxxxxxxxxx
19283                                                                 ssubw.  */
19284                                                              return 50;
19285                                                            }
19286                                                          else
19287                                                            {
19288                                                              /* 33222222222211111111110000000000
19289                                                                 10987654321098765432109876543210
19290                                                                 01001110xx1xxxxx001100xxxxxxxxxx
19291                                                                 ssubw2.  */
19292                                                              return 51;
19293                                                            }
19294                                                        }
19295                                                      else
19296                                                        {
19297                                                          if (((word >> 30) & 0x1) == 0)
19298                                                            {
19299                                                              /* 33222222222211111111110000000000
19300                                                                 10987654321098765432109876543210
19301                                                                 00001110xx1xxxxx011100xxxxxxxxxx
19302                                                                 sabdl.  */
19303                                                              return 58;
19304                                                            }
19305                                                          else
19306                                                            {
19307                                                              /* 33222222222211111111110000000000
19308                                                                 10987654321098765432109876543210
19309                                                                 01001110xx1xxxxx011100xxxxxxxxxx
19310                                                                 sabdl2.  */
19311                                                              return 59;
19312                                                            }
19313                                                        }
19314                                                    }
19315                                                }
19316                                            }
19317                                          else
19318                                            {
19319                                              if (((word >> 12) & 0x1) == 0)
19320                                                {
19321                                                  if (((word >> 13) & 0x1) == 0)
19322                                                    {
19323                                                      if (((word >> 14) & 0x1) == 0)
19324                                                        {
19325                                                          /* 33222222222211111111110000000000
19326                                                             10987654321098765432109876543210
19327                                                             0x001110xx1xxxxx000010xxxxxxxxxx
19328                                                             rev64.  */
19329                                                          return 162;
19330                                                        }
19331                                                      else
19332                                                        {
19333                                                          if (((word >> 16) & 0x1) == 0)
19334                                                            {
19335                                                              if (((word >> 19) & 0x1) == 0)
19336                                                                {
19337                                                                  /* 33222222222211111111110000000000
19338                                                                     10987654321098765432109876543210
19339                                                                     0x001110xx1x0xx0010010xxxxxxxxxx
19340                                                                     cls.  */
19341                                                                  return 166;
19342                                                                }
19343                                                              else
19344                                                                {
19345                                                                  /* 33222222222211111111110000000000
19346                                                                     10987654321098765432109876543210
19347                                                                     0x001110xx1x1xx0010010xxxxxxxxxx
19348                                                                     aese.  */
19349                                                                  return 671;
19350                                                                }
19351                                                            }
19352                                                          else
19353                                                            {
19354                                                              if (((word >> 30) & 0x1) == 0)
19355                                                                {
19356                                                                  /* 33222222222211111111110000000000
19357                                                                     10987654321098765432109876543210
19358                                                                     00001110xx1xxxx1010010xxxxxxxxxx
19359                                                                     sqxtn.  */
19360                                                                  return 176;
19361                                                                }
19362                                                              else
19363                                                                {
19364                                                                  /* 33222222222211111111110000000000
19365                                                                     10987654321098765432109876543210
19366                                                                     01001110xx1xxxx1010010xxxxxxxxxx
19367                                                                     sqxtn2.  */
19368                                                                  return 177;
19369                                                                }
19370                                                            }
19371                                                        }
19372                                                    }
19373                                                  else
19374                                                    {
19375                                                      if (((word >> 14) & 0x1) == 0)
19376                                                        {
19377                                                          if (((word >> 16) & 0x1) == 0)
19378                                                            {
19379                                                              /* 33222222222211111111110000000000
19380                                                                 10987654321098765432109876543210
19381                                                                 0x001110xx1xxxx0001010xxxxxxxxxx
19382                                                                 saddlp.  */
19383                                                              return 164;
19384                                                            }
19385                                                          else
19386                                                            {
19387                                                              if (((word >> 30) & 0x1) == 0)
19388                                                                {
19389                                                                  /* 33222222222211111111110000000000
19390                                                                     10987654321098765432109876543210
19391                                                                     00001110xx1xxxx1001010xxxxxxxxxx
19392                                                                     xtn.  */
19393                                                                  return 174;
19394                                                                }
19395                                                              else
19396                                                                {
19397                                                                  /* 33222222222211111111110000000000
19398                                                                     10987654321098765432109876543210
19399                                                                     01001110xx1xxxx1001010xxxxxxxxxx
19400                                                                     xtn2.  */
19401                                                                  return 175;
19402                                                                }
19403                                                            }
19404                                                        }
19405                                                      else
19406                                                        {
19407                                                          if (((word >> 16) & 0x1) == 0)
19408                                                            {
19409                                                              if (((word >> 19) & 0x1) == 0)
19410                                                                {
19411                                                                  /* 33222222222211111111110000000000
19412                                                                     10987654321098765432109876543210
19413                                                                     0x001110xx1x0xx0011010xxxxxxxxxx
19414                                                                     sadalp.  */
19415                                                                  return 168;
19416                                                                }
19417                                                              else
19418                                                                {
19419                                                                  /* 33222222222211111111110000000000
19420                                                                     10987654321098765432109876543210
19421                                                                     0x001110xx1x1xx0011010xxxxxxxxxx
19422                                                                     aesmc.  */
19423                                                                  return 673;
19424                                                                }
19425                                                            }
19426                                                          else
19427                                                            {
19428                                                              if (((word >> 23) & 0x1) == 0)
19429                                                                {
19430                                                                  if (((word >> 30) & 0x1) == 0)
19431                                                                    {
19432                                                                      /* 33222222222211111111110000000000
19433                                                                         10987654321098765432109876543210
19434                                                                         000011100x1xxxx1011010xxxxxxxxxx
19435                                                                         fcvtn.  */
19436                                                                      return 178;
19437                                                                    }
19438                                                                  else
19439                                                                    {
19440                                                                      /* 33222222222211111111110000000000
19441                                                                         10987654321098765432109876543210
19442                                                                         010011100x1xxxx1011010xxxxxxxxxx
19443                                                                         fcvtn2.  */
19444                                                                      return 179;
19445                                                                    }
19446                                                                }
19447                                                              else
19448                                                                {
19449                                                                  if (((word >> 30) & 0x1) == 0)
19450                                                                    {
19451                                                                      /* 33222222222211111111110000000000
19452                                                                         10987654321098765432109876543210
19453                                                                         000011101x1xxxx1011010xxxxxxxxxx
19454                                                                         bfcvtn.  */
19455                                                                      return 2507;
19456                                                                    }
19457                                                                  else
19458                                                                    {
19459                                                                      /* 33222222222211111111110000000000
19460                                                                         10987654321098765432109876543210
19461                                                                         010011101x1xxxx1011010xxxxxxxxxx
19462                                                                         bfcvtn2.  */
19463                                                                      return 2508;
19464                                                                    }
19465                                                                }
19466                                                            }
19467                                                        }
19468                                                    }
19469                                                }
19470                                              else
19471                                                {
19472                                                  if (((word >> 13) & 0x1) == 0)
19473                                                    {
19474                                                      if (((word >> 14) & 0x1) == 0)
19475                                                        {
19476                                                          /* 33222222222211111111110000000000
19477                                                             10987654321098765432109876543210
19478                                                             0x001110xx1xxxxx000110xxxxxxxxxx
19479                                                             rev16.  */
19480                                                          return 163;
19481                                                        }
19482                                                      else
19483                                                        {
19484                                                          if (((word >> 19) & 0x1) == 0)
19485                                                            {
19486                                                              /* 33222222222211111111110000000000
19487                                                                 10987654321098765432109876543210
19488                                                                 0x001110xx1x0xxx010110xxxxxxxxxx
19489                                                                 cnt.  */
19490                                                              return 167;
19491                                                            }
19492                                                          else
19493                                                            {
19494                                                              /* 33222222222211111111110000000000
19495                                                                 10987654321098765432109876543210
19496                                                                 0x001110xx1x1xxx010110xxxxxxxxxx
19497                                                                 aesd.  */
19498                                                              return 672;
19499                                                            }
19500                                                        }
19501                                                    }
19502                                                  else
19503                                                    {
19504                                                      if (((word >> 14) & 0x1) == 0)
19505                                                        {
19506                                                          if (((word >> 20) & 0x1) == 0)
19507                                                            {
19508                                                              /* 33222222222211111111110000000000
19509                                                                 10987654321098765432109876543210
19510                                                                 0x001110xx10xxxx001110xxxxxxxxxx
19511                                                                 suqadd.  */
19512                                                              return 165;
19513                                                            }
19514                                                          else
19515                                                            {
19516                                                              /* 33222222222211111111110000000000
19517                                                                 10987654321098765432109876543210
19518                                                                 0x001110xx11xxxx001110xxxxxxxxxx
19519                                                                 saddlv.  */
19520                                                              return 29;
19521                                                            }
19522                                                        }
19523                                                      else
19524                                                        {
19525                                                          if (((word >> 16) & 0x1) == 0)
19526                                                            {
19527                                                              if (((word >> 19) & 0x1) == 0)
19528                                                                {
19529                                                                  /* 33222222222211111111110000000000
19530                                                                     10987654321098765432109876543210
19531                                                                     0x001110xx1x0xx0011110xxxxxxxxxx
19532                                                                     sqabs.  */
19533                                                                  return 169;
19534                                                                }
19535                                                              else
19536                                                                {
19537                                                                  /* 33222222222211111111110000000000
19538                                                                     10987654321098765432109876543210
19539                                                                     0x001110xx1x1xx0011110xxxxxxxxxx
19540                                                                     aesimc.  */
19541                                                                  return 674;
19542                                                                }
19543                                                            }
19544                                                          else
19545                                                            {
19546                                                              if (((word >> 30) & 0x1) == 0)
19547                                                                {
19548                                                                  /* 33222222222211111111110000000000
19549                                                                     10987654321098765432109876543210
19550                                                                     00001110xx1xxxx1011110xxxxxxxxxx
19551                                                                     fcvtl.  */
19552                                                                  return 180;
19553                                                                }
19554                                                              else
19555                                                                {
19556                                                                  /* 33222222222211111111110000000000
19557                                                                     10987654321098765432109876543210
19558                                                                     01001110xx1xxxx1011110xxxxxxxxxx
19559                                                                     fcvtl2.  */
19560                                                                  return 181;
19561                                                                }
19562                                                            }
19563                                                        }
19564                                                    }
19565                                                }
19566                                            }
19567                                        }
19568                                      else
19569                                        {
19570                                          if (((word >> 11) & 0x1) == 0)
19571                                            {
19572                                              if (((word >> 12) & 0x1) == 0)
19573                                                {
19574                                                  if (((word >> 13) & 0x1) == 0)
19575                                                    {
19576                                                      if (((word >> 14) & 0x1) == 0)
19577                                                        {
19578                                                          /* 33222222222211111111110000000000
19579                                                             10987654321098765432109876543210
19580                                                             0x001110xx1xxxxx000001xxxxxxxxxx
19581                                                             shadd.  */
19582                                                          return 268;
19583                                                        }
19584                                                      else
19585                                                        {
19586                                                          /* 33222222222211111111110000000000
19587                                                             10987654321098765432109876543210
19588                                                             0x001110xx1xxxxx010001xxxxxxxxxx
19589                                                             sshl.  */
19590                                                          return 275;
19591                                                        }
19592                                                    }
19593                                                  else
19594                                                    {
19595                                                      if (((word >> 14) & 0x1) == 0)
19596                                                        {
19597                                                          /* 33222222222211111111110000000000
19598                                                             10987654321098765432109876543210
19599                                                             0x001110xx1xxxxx001001xxxxxxxxxx
19600                                                             shsub.  */
19601                                                          return 271;
19602                                                        }
19603                                                      else
19604                                                        {
19605                                                          /* 33222222222211111111110000000000
19606                                                             10987654321098765432109876543210
19607                                                             0x001110xx1xxxxx011001xxxxxxxxxx
19608                                                             smax.  */
19609                                                          return 279;
19610                                                        }
19611                                                    }
19612                                                }
19613                                              else
19614                                                {
19615                                                  if (((word >> 13) & 0x1) == 0)
19616                                                    {
19617                                                      if (((word >> 14) & 0x1) == 0)
19618                                                        {
19619                                                          /* 33222222222211111111110000000000
19620                                                             10987654321098765432109876543210
19621                                                             0x001110xx1xxxxx000101xxxxxxxxxx
19622                                                             srhadd.  */
19623                                                          return 270;
19624                                                        }
19625                                                      else
19626                                                        {
19627                                                          /* 33222222222211111111110000000000
19628                                                             10987654321098765432109876543210
19629                                                             0x001110xx1xxxxx010101xxxxxxxxxx
19630                                                             srshl.  */
19631                                                          return 277;
19632                                                        }
19633                                                    }
19634                                                  else
19635                                                    {
19636                                                      if (((word >> 14) & 0x1) == 0)
19637                                                        {
19638                                                          /* 33222222222211111111110000000000
19639                                                             10987654321098765432109876543210
19640                                                             0x001110xx1xxxxx001101xxxxxxxxxx
19641                                                             cmgt.  */
19642                                                          return 273;
19643                                                        }
19644                                                      else
19645                                                        {
19646                                                          /* 33222222222211111111110000000000
19647                                                             10987654321098765432109876543210
19648                                                             0x001110xx1xxxxx011101xxxxxxxxxx
19649                                                             sabd.  */
19650                                                          return 281;
19651                                                        }
19652                                                    }
19653                                                }
19654                                            }
19655                                          else
19656                                            {
19657                                              if (((word >> 12) & 0x1) == 0)
19658                                                {
19659                                                  if (((word >> 13) & 0x1) == 0)
19660                                                    {
19661                                                      if (((word >> 14) & 0x1) == 0)
19662                                                        {
19663                                                          /* 33222222222211111111110000000000
19664                                                             10987654321098765432109876543210
19665                                                             0x001110xx1xxxxx000011xxxxxxxxxx
19666                                                             sqadd.  */
19667                                                          return 269;
19668                                                        }
19669                                                      else
19670                                                        {
19671                                                          /* 33222222222211111111110000000000
19672                                                             10987654321098765432109876543210
19673                                                             0x001110xx1xxxxx010011xxxxxxxxxx
19674                                                             sqshl.  */
19675                                                          return 276;
19676                                                        }
19677                                                    }
19678                                                  else
19679                                                    {
19680                                                      if (((word >> 14) & 0x1) == 0)
19681                                                        {
19682                                                          /* 33222222222211111111110000000000
19683                                                             10987654321098765432109876543210
19684                                                             0x001110xx1xxxxx001011xxxxxxxxxx
19685                                                             sqsub.  */
19686                                                          return 272;
19687                                                        }
19688                                                      else
19689                                                        {
19690                                                          /* 33222222222211111111110000000000
19691                                                             10987654321098765432109876543210
19692                                                             0x001110xx1xxxxx011011xxxxxxxxxx
19693                                                             smin.  */
19694                                                          return 280;
19695                                                        }
19696                                                    }
19697                                                }
19698                                              else
19699                                                {
19700                                                  if (((word >> 13) & 0x1) == 0)
19701                                                    {
19702                                                      if (((word >> 14) & 0x1) == 0)
19703                                                        {
19704                                                          if (((word >> 22) & 0x1) == 0)
19705                                                            {
19706                                                              if (((word >> 23) & 0x1) == 0)
19707                                                                {
19708                                                                  /* 33222222222211111111110000000000
19709                                                                     10987654321098765432109876543210
19710                                                                     0x001110001xxxxx000111xxxxxxxxxx
19711                                                                     and.  */
19712                                                                  return 305;
19713                                                                }
19714                                                              else
19715                                                                {
19716                                                                  /* 33222222222211111111110000000000
19717                                                                     10987654321098765432109876543210
19718                                                                     0x001110101xxxxx000111xxxxxxxxxx
19719                                                                     orr.  */
19720                                                                  return 317;
19721                                                                }
19722                                                            }
19723                                                          else
19724                                                            {
19725                                                              if (((word >> 23) & 0x1) == 0)
19726                                                                {
19727                                                                  /* 33222222222211111111110000000000
19728                                                                     10987654321098765432109876543210
19729                                                                     0x001110011xxxxx000111xxxxxxxxxx
19730                                                                     bic.  */
19731                                                                  return 306;
19732                                                                }
19733                                                              else
19734                                                                {
19735                                                                  /* 33222222222211111111110000000000
19736                                                                     10987654321098765432109876543210
19737                                                                     0x001110111xxxxx000111xxxxxxxxxx
19738                                                                     orn.  */
19739                                                                  return 319;
19740                                                                }
19741                                                            }
19742                                                        }
19743                                                      else
19744                                                        {
19745                                                          /* 33222222222211111111110000000000
19746                                                             10987654321098765432109876543210
19747                                                             0x001110xx1xxxxx010111xxxxxxxxxx
19748                                                             sqrshl.  */
19749                                                          return 278;
19750                                                        }
19751                                                    }
19752                                                  else
19753                                                    {
19754                                                      if (((word >> 14) & 0x1) == 0)
19755                                                        {
19756                                                          /* 33222222222211111111110000000000
19757                                                             10987654321098765432109876543210
19758                                                             0x001110xx1xxxxx001111xxxxxxxxxx
19759                                                             cmge.  */
19760                                                          return 274;
19761                                                        }
19762                                                      else
19763                                                        {
19764                                                          /* 33222222222211111111110000000000
19765                                                             10987654321098765432109876543210
19766                                                             0x001110xx1xxxxx011111xxxxxxxxxx
19767                                                             saba.  */
19768                                                          return 282;
19769                                                        }
19770                                                    }
19771                                                }
19772                                            }
19773                                        }
19774                                    }
19775                                  else
19776                                    {
19777                                      /* 33222222222211111111110000000000
19778                                         10987654321098765432109876543210
19779                                         1x001110xx1xxxxx0xxxxxxxxxxxxxxx
19780                                         bcax.  */
19781                                      return 2425;
19782                                    }
19783                                }
19784                              else
19785                                {
19786                                  if (((word >> 10) & 0x1) == 0)
19787                                    {
19788                                      if (((word >> 11) & 0x1) == 0)
19789                                        {
19790                                          if (((word >> 12) & 0x1) == 0)
19791                                            {
19792                                              if (((word >> 13) & 0x1) == 0)
19793                                                {
19794                                                  if (((word >> 14) & 0x1) == 0)
19795                                                    {
19796                                                      if (((word >> 30) & 0x1) == 0)
19797                                                        {
19798                                                          /* 33222222222211111111110000000000
19799                                                             10987654321098765432109876543210
19800                                                             x0101110xx1xxxxx000000xxxxxxxxxx
19801                                                             uaddl.  */
19802                                                          return 76;
19803                                                        }
19804                                                      else
19805                                                        {
19806                                                          /* 33222222222211111111110000000000
19807                                                             10987654321098765432109876543210
19808                                                             x1101110xx1xxxxx000000xxxxxxxxxx
19809                                                             uaddl2.  */
19810                                                          return 77;
19811                                                        }
19812                                                    }
19813                                                  else
19814                                                    {
19815                                                      if (((word >> 30) & 0x1) == 0)
19816                                                        {
19817                                                          /* 33222222222211111111110000000000
19818                                                             10987654321098765432109876543210
19819                                                             x0101110xx1xxxxx010000xxxxxxxxxx
19820                                                             raddhn.  */
19821                                                          return 84;
19822                                                        }
19823                                                      else
19824                                                        {
19825                                                          /* 33222222222211111111110000000000
19826                                                             10987654321098765432109876543210
19827                                                             x1101110xx1xxxxx010000xxxxxxxxxx
19828                                                             raddhn2.  */
19829                                                          return 85;
19830                                                        }
19831                                                    }
19832                                                }
19833                                              else
19834                                                {
19835                                                  if (((word >> 14) & 0x1) == 0)
19836                                                    {
19837                                                      if (((word >> 30) & 0x1) == 0)
19838                                                        {
19839                                                          /* 33222222222211111111110000000000
19840                                                             10987654321098765432109876543210
19841                                                             x0101110xx1xxxxx001000xxxxxxxxxx
19842                                                             usubl.  */
19843                                                          return 80;
19844                                                        }
19845                                                      else
19846                                                        {
19847                                                          /* 33222222222211111111110000000000
19848                                                             10987654321098765432109876543210
19849                                                             x1101110xx1xxxxx001000xxxxxxxxxx
19850                                                             usubl2.  */
19851                                                          return 81;
19852                                                        }
19853                                                    }
19854                                                  else
19855                                                    {
19856                                                      if (((word >> 30) & 0x1) == 0)
19857                                                        {
19858                                                          /* 33222222222211111111110000000000
19859                                                             10987654321098765432109876543210
19860                                                             x0101110xx1xxxxx011000xxxxxxxxxx
19861                                                             rsubhn.  */
19862                                                          return 88;
19863                                                        }
19864                                                      else
19865                                                        {
19866                                                          /* 33222222222211111111110000000000
19867                                                             10987654321098765432109876543210
19868                                                             x1101110xx1xxxxx011000xxxxxxxxxx
19869                                                             rsubhn2.  */
19870                                                          return 89;
19871                                                        }
19872                                                    }
19873                                                }
19874                                            }
19875                                          else
19876                                            {
19877                                              if (((word >> 13) & 0x1) == 0)
19878                                                {
19879                                                  if (((word >> 14) & 0x1) == 0)
19880                                                    {
19881                                                      if (((word >> 30) & 0x1) == 0)
19882                                                        {
19883                                                          /* 33222222222211111111110000000000
19884                                                             10987654321098765432109876543210
19885                                                             x0101110xx1xxxxx000100xxxxxxxxxx
19886                                                             uaddw.  */
19887                                                          return 78;
19888                                                        }
19889                                                      else
19890                                                        {
19891                                                          /* 33222222222211111111110000000000
19892                                                             10987654321098765432109876543210
19893                                                             x1101110xx1xxxxx000100xxxxxxxxxx
19894                                                             uaddw2.  */
19895                                                          return 79;
19896                                                        }
19897                                                    }
19898                                                  else
19899                                                    {
19900                                                      if (((word >> 30) & 0x1) == 0)
19901                                                        {
19902                                                          /* 33222222222211111111110000000000
19903                                                             10987654321098765432109876543210
19904                                                             x0101110xx1xxxxx010100xxxxxxxxxx
19905                                                             uabal.  */
19906                                                          return 86;
19907                                                        }
19908                                                      else
19909                                                        {
19910                                                          /* 33222222222211111111110000000000
19911                                                             10987654321098765432109876543210
19912                                                             x1101110xx1xxxxx010100xxxxxxxxxx
19913                                                             uabal2.  */
19914                                                          return 87;
19915                                                        }
19916                                                    }
19917                                                }
19918                                              else
19919                                                {
19920                                                  if (((word >> 14) & 0x1) == 0)
19921                                                    {
19922                                                      if (((word >> 30) & 0x1) == 0)
19923                                                        {
19924                                                          /* 33222222222211111111110000000000
19925                                                             10987654321098765432109876543210
19926                                                             x0101110xx1xxxxx001100xxxxxxxxxx
19927                                                             usubw.  */
19928                                                          return 82;
19929                                                        }
19930                                                      else
19931                                                        {
19932                                                          /* 33222222222211111111110000000000
19933                                                             10987654321098765432109876543210
19934                                                             x1101110xx1xxxxx001100xxxxxxxxxx
19935                                                             usubw2.  */
19936                                                          return 83;
19937                                                        }
19938                                                    }
19939                                                  else
19940                                                    {
19941                                                      if (((word >> 30) & 0x1) == 0)
19942                                                        {
19943                                                          /* 33222222222211111111110000000000
19944                                                             10987654321098765432109876543210
19945                                                             x0101110xx1xxxxx011100xxxxxxxxxx
19946                                                             uabdl.  */
19947                                                          return 90;
19948                                                        }
19949                                                      else
19950                                                        {
19951                                                          /* 33222222222211111111110000000000
19952                                                             10987654321098765432109876543210
19953                                                             x1101110xx1xxxxx011100xxxxxxxxxx
19954                                                             uabdl2.  */
19955                                                          return 91;
19956                                                        }
19957                                                    }
19958                                                }
19959                                            }
19960                                        }
19961                                      else
19962                                        {
19963                                          if (((word >> 12) & 0x1) == 0)
19964                                            {
19965                                              if (((word >> 13) & 0x1) == 0)
19966                                                {
19967                                                  if (((word >> 14) & 0x1) == 0)
19968                                                    {
19969                                                      /* 33222222222211111111110000000000
19970                                                         10987654321098765432109876543210
19971                                                         xx101110xx1xxxxx000010xxxxxxxxxx
19972                                                         rev32.  */
19973                                                      return 213;
19974                                                    }
19975                                                  else
19976                                                    {
19977                                                      if (((word >> 16) & 0x1) == 0)
19978                                                        {
19979                                                          /* 33222222222211111111110000000000
19980                                                             10987654321098765432109876543210
19981                                                             xx101110xx1xxxx0010010xxxxxxxxxx
19982                                                             clz.  */
19983                                                          return 216;
19984                                                        }
19985                                                      else
19986                                                        {
19987                                                          if (((word >> 30) & 0x1) == 0)
19988                                                            {
19989                                                              /* 33222222222211111111110000000000
19990                                                                 10987654321098765432109876543210
19991                                                                 x0101110xx1xxxx1010010xxxxxxxxxx
19992                                                                 uqxtn.  */
19993                                                              return 226;
19994                                                            }
19995                                                          else
19996                                                            {
19997                                                              /* 33222222222211111111110000000000
19998                                                                 10987654321098765432109876543210
19999                                                                 x1101110xx1xxxx1010010xxxxxxxxxx
20000                                                                 uqxtn2.  */
20001                                                              return 227;
20002                                                            }
20003                                                        }
20004                                                    }
20005                                                }
20006                                              else
20007                                                {
20008                                                  if (((word >> 14) & 0x1) == 0)
20009                                                    {
20010                                                      if (((word >> 16) & 0x1) == 0)
20011                                                        {
20012                                                          /* 33222222222211111111110000000000
20013                                                             10987654321098765432109876543210
20014                                                             xx101110xx1xxxx0001010xxxxxxxxxx
20015                                                             uaddlp.  */
20016                                                          return 214;
20017                                                        }
20018                                                      else
20019                                                        {
20020                                                          if (((word >> 30) & 0x1) == 0)
20021                                                            {
20022                                                              /* 33222222222211111111110000000000
20023                                                                 10987654321098765432109876543210
20024                                                                 x0101110xx1xxxx1001010xxxxxxxxxx
20025                                                                 sqxtun.  */
20026                                                              return 222;
20027                                                            }
20028                                                          else
20029                                                            {
20030                                                              /* 33222222222211111111110000000000
20031                                                                 10987654321098765432109876543210
20032                                                                 x1101110xx1xxxx1001010xxxxxxxxxx
20033                                                                 sqxtun2.  */
20034                                                              return 223;
20035                                                            }
20036                                                        }
20037                                                    }
20038                                                  else
20039                                                    {
20040                                                      if (((word >> 16) & 0x1) == 0)
20041                                                        {
20042                                                          /* 33222222222211111111110000000000
20043                                                             10987654321098765432109876543210
20044                                                             xx101110xx1xxxx0011010xxxxxxxxxx
20045                                                             uadalp.  */
20046                                                          return 217;
20047                                                        }
20048                                                      else
20049                                                        {
20050                                                          if (((word >> 30) & 0x1) == 0)
20051                                                            {
20052                                                              /* 33222222222211111111110000000000
20053                                                                 10987654321098765432109876543210
20054                                                                 x0101110xx1xxxx1011010xxxxxxxxxx
20055                                                                 fcvtxn.  */
20056                                                              return 228;
20057                                                            }
20058                                                          else
20059                                                            {
20060                                                              /* 33222222222211111111110000000000
20061                                                                 10987654321098765432109876543210
20062                                                                 x1101110xx1xxxx1011010xxxxxxxxxx
20063                                                                 fcvtxn2.  */
20064                                                              return 229;
20065                                                            }
20066                                                        }
20067                                                    }
20068                                                }
20069                                            }
20070                                          else
20071                                            {
20072                                              if (((word >> 13) & 0x1) == 0)
20073                                                {
20074                                                  if (((word >> 22) & 0x1) == 0)
20075                                                    {
20076                                                      /* 33222222222211111111110000000000
20077                                                         10987654321098765432109876543210
20078                                                         xx101110x01xxxxx0x0110xxxxxxxxxx
20079                                                         not.  */
20080                                                      return 242;
20081                                                    }
20082                                                  else
20083                                                    {
20084                                                      /* 33222222222211111111110000000000
20085                                                         10987654321098765432109876543210
20086                                                         xx101110x11xxxxx0x0110xxxxxxxxxx
20087                                                         rbit.  */
20088                                                      return 244;
20089                                                    }
20090                                                }
20091                                              else
20092                                                {
20093                                                  if (((word >> 14) & 0x1) == 0)
20094                                                    {
20095                                                      if (((word >> 16) & 0x1) == 0)
20096                                                        {
20097                                                          if (((word >> 20) & 0x1) == 0)
20098                                                            {
20099                                                              /* 33222222222211111111110000000000
20100                                                                 10987654321098765432109876543210
20101                                                                 xx101110xx10xxx0001110xxxxxxxxxx
20102                                                                 usqadd.  */
20103                                                              return 215;
20104                                                            }
20105                                                          else
20106                                                            {
20107                                                              /* 33222222222211111111110000000000
20108                                                                 10987654321098765432109876543210
20109                                                                 xx101110xx11xxx0001110xxxxxxxxxx
20110                                                                 uaddlv.  */
20111                                                              return 33;
20112                                                            }
20113                                                        }
20114                                                      else
20115                                                        {
20116                                                          if (((word >> 30) & 0x1) == 0)
20117                                                            {
20118                                                              /* 33222222222211111111110000000000
20119                                                                 10987654321098765432109876543210
20120                                                                 x0101110xx1xxxx1001110xxxxxxxxxx
20121                                                                 shll.  */
20122                                                              return 224;
20123                                                            }
20124                                                          else
20125                                                            {
20126                                                              /* 33222222222211111111110000000000
20127                                                                 10987654321098765432109876543210
20128                                                                 x1101110xx1xxxx1001110xxxxxxxxxx
20129                                                                 shll2.  */
20130                                                              return 225;
20131                                                            }
20132                                                        }
20133                                                    }
20134                                                  else
20135                                                    {
20136                                                      /* 33222222222211111111110000000000
20137                                                         10987654321098765432109876543210
20138                                                         xx101110xx1xxxxx011110xxxxxxxxxx
20139                                                         sqneg.  */
20140                                                      return 218;
20141                                                    }
20142                                                }
20143                                            }
20144                                        }
20145                                    }
20146                                  else
20147                                    {
20148                                      if (((word >> 11) & 0x1) == 0)
20149                                        {
20150                                          if (((word >> 12) & 0x1) == 0)
20151                                            {
20152                                              if (((word >> 13) & 0x1) == 0)
20153                                                {
20154                                                  if (((word >> 14) & 0x1) == 0)
20155                                                    {
20156                                                      /* 33222222222211111111110000000000
20157                                                         10987654321098765432109876543210
20158                                                         xx101110xx1xxxxx000001xxxxxxxxxx
20159                                                         uhadd.  */
20160                                                      return 320;
20161                                                    }
20162                                                  else
20163                                                    {
20164                                                      /* 33222222222211111111110000000000
20165                                                         10987654321098765432109876543210
20166                                                         xx101110xx1xxxxx010001xxxxxxxxxx
20167                                                         ushl.  */
20168                                                      return 327;
20169                                                    }
20170                                                }
20171                                              else
20172                                                {
20173                                                  if (((word >> 14) & 0x1) == 0)
20174                                                    {
20175                                                      /* 33222222222211111111110000000000
20176                                                         10987654321098765432109876543210
20177                                                         xx101110xx1xxxxx001001xxxxxxxxxx
20178                                                         uhsub.  */
20179                                                      return 323;
20180                                                    }
20181                                                  else
20182                                                    {
20183                                                      /* 33222222222211111111110000000000
20184                                                         10987654321098765432109876543210
20185                                                         xx101110xx1xxxxx011001xxxxxxxxxx
20186                                                         umax.  */
20187                                                      return 331;
20188                                                    }
20189                                                }
20190                                            }
20191                                          else
20192                                            {
20193                                              if (((word >> 13) & 0x1) == 0)
20194                                                {
20195                                                  if (((word >> 14) & 0x1) == 0)
20196                                                    {
20197                                                      /* 33222222222211111111110000000000
20198                                                         10987654321098765432109876543210
20199                                                         xx101110xx1xxxxx000101xxxxxxxxxx
20200                                                         urhadd.  */
20201                                                      return 322;
20202                                                    }
20203                                                  else
20204                                                    {
20205                                                      /* 33222222222211111111110000000000
20206                                                         10987654321098765432109876543210
20207                                                         xx101110xx1xxxxx010101xxxxxxxxxx
20208                                                         urshl.  */
20209                                                      return 329;
20210                                                    }
20211                                                }
20212                                              else
20213                                                {
20214                                                  if (((word >> 14) & 0x1) == 0)
20215                                                    {
20216                                                      /* 33222222222211111111110000000000
20217                                                         10987654321098765432109876543210
20218                                                         xx101110xx1xxxxx001101xxxxxxxxxx
20219                                                         cmhi.  */
20220                                                      return 325;
20221                                                    }
20222                                                  else
20223                                                    {
20224                                                      /* 33222222222211111111110000000000
20225                                                         10987654321098765432109876543210
20226                                                         xx101110xx1xxxxx011101xxxxxxxxxx
20227                                                         uabd.  */
20228                                                      return 333;
20229                                                    }
20230                                                }
20231                                            }
20232                                        }
20233                                      else
20234                                        {
20235                                          if (((word >> 12) & 0x1) == 0)
20236                                            {
20237                                              if (((word >> 13) & 0x1) == 0)
20238                                                {
20239                                                  if (((word >> 14) & 0x1) == 0)
20240                                                    {
20241                                                      /* 33222222222211111111110000000000
20242                                                         10987654321098765432109876543210
20243                                                         xx101110xx1xxxxx000011xxxxxxxxxx
20244                                                         uqadd.  */
20245                                                      return 321;
20246                                                    }
20247                                                  else
20248                                                    {
20249                                                      /* 33222222222211111111110000000000
20250                                                         10987654321098765432109876543210
20251                                                         xx101110xx1xxxxx010011xxxxxxxxxx
20252                                                         uqshl.  */
20253                                                      return 328;
20254                                                    }
20255                                                }
20256                                              else
20257                                                {
20258                                                  if (((word >> 14) & 0x1) == 0)
20259                                                    {
20260                                                      /* 33222222222211111111110000000000
20261                                                         10987654321098765432109876543210
20262                                                         xx101110xx1xxxxx001011xxxxxxxxxx
20263                                                         uqsub.  */
20264                                                      return 324;
20265                                                    }
20266                                                  else
20267                                                    {
20268                                                      /* 33222222222211111111110000000000
20269                                                         10987654321098765432109876543210
20270                                                         xx101110xx1xxxxx011011xxxxxxxxxx
20271                                                         umin.  */
20272                                                      return 332;
20273                                                    }
20274                                                }
20275                                            }
20276                                          else
20277                                            {
20278                                              if (((word >> 13) & 0x1) == 0)
20279                                                {
20280                                                  if (((word >> 14) & 0x1) == 0)
20281                                                    {
20282                                                      if (((word >> 22) & 0x1) == 0)
20283                                                        {
20284                                                          if (((word >> 23) & 0x1) == 0)
20285                                                            {
20286                                                              /* 33222222222211111111110000000000
20287                                                                 10987654321098765432109876543210
20288                                                                 xx101110001xxxxx000111xxxxxxxxxx
20289                                                                 eor.  */
20290                                                              return 356;
20291                                                            }
20292                                                          else
20293                                                            {
20294                                                              /* 33222222222211111111110000000000
20295                                                                 10987654321098765432109876543210
20296                                                                 xx101110101xxxxx000111xxxxxxxxxx
20297                                                                 bit.  */
20298                                                              return 368;
20299                                                            }
20300                                                        }
20301                                                      else
20302                                                        {
20303                                                          if (((word >> 23) & 0x1) == 0)
20304                                                            {
20305                                                              /* 33222222222211111111110000000000
20306                                                                 10987654321098765432109876543210
20307                                                                 xx101110011xxxxx000111xxxxxxxxxx
20308                                                                 bsl.  */
20309                                                              return 357;
20310                                                            }
20311                                                          else
20312                                                            {
20313                                                              /* 33222222222211111111110000000000
20314                                                                 10987654321098765432109876543210
20315                                                                 xx101110111xxxxx000111xxxxxxxxxx
20316                                                                 bif.  */
20317                                                              return 369;
20318                                                            }
20319                                                        }
20320                                                    }
20321                                                  else
20322                                                    {
20323                                                      /* 33222222222211111111110000000000
20324                                                         10987654321098765432109876543210
20325                                                         xx101110xx1xxxxx010111xxxxxxxxxx
20326                                                         uqrshl.  */
20327                                                      return 330;
20328                                                    }
20329                                                }
20330                                              else
20331                                                {
20332                                                  if (((word >> 14) & 0x1) == 0)
20333                                                    {
20334                                                      /* 33222222222211111111110000000000
20335                                                         10987654321098765432109876543210
20336                                                         xx101110xx1xxxxx001111xxxxxxxxxx
20337                                                         cmhs.  */
20338                                                      return 326;
20339                                                    }
20340                                                  else
20341                                                    {
20342                                                      /* 33222222222211111111110000000000
20343                                                         10987654321098765432109876543210
20344                                                         xx101110xx1xxxxx011111xxxxxxxxxx
20345                                                         uaba.  */
20346                                                      return 334;
20347                                                    }
20348                                                }
20349                                            }
20350                                        }
20351                                    }
20352                                }
20353                            }
20354                          else
20355                            {
20356                              if (((word >> 10) & 0x1) == 0)
20357                                {
20358                                  if (((word >> 11) & 0x1) == 0)
20359                                    {
20360                                      if (((word >> 12) & 0x1) == 0)
20361                                        {
20362                                          if (((word >> 13) & 0x1) == 0)
20363                                            {
20364                                              if (((word >> 14) & 0x1) == 0)
20365                                                {
20366                                                  if (((word >> 29) & 0x1) == 0)
20367                                                    {
20368                                                      if (((word >> 30) & 0x1) == 0)
20369                                                        {
20370                                                          /* 33222222222211111111110000000000
20371                                                             10987654321098765432109876543210
20372                                                             x0001110xx1xxxxx100000xxxxxxxxxx
20373                                                             smlal.  */
20374                                                          return 60;
20375                                                        }
20376                                                      else
20377                                                        {
20378                                                          if (((word >> 31) & 0x1) == 0)
20379                                                            {
20380                                                              /* 33222222222211111111110000000000
20381                                                                 10987654321098765432109876543210
20382                                                                 01001110xx1xxxxx100000xxxxxxxxxx
20383                                                                 smlal2.  */
20384                                                              return 61;
20385                                                            }
20386                                                          else
20387                                                            {
20388                                                              /* 33222222222211111111110000000000
20389                                                                 10987654321098765432109876543210
20390                                                                 11001110xx1xxxxx100000xxxxxxxxxx
20391                                                                 sha512h.  */
20392                                                              return 2418;
20393                                                            }
20394                                                        }
20395                                                    }
20396                                                  else
20397                                                    {
20398                                                      if (((word >> 30) & 0x1) == 0)
20399                                                        {
20400                                                          /* 33222222222211111111110000000000
20401                                                             10987654321098765432109876543210
20402                                                             x0101110xx1xxxxx100000xxxxxxxxxx
20403                                                             umlal.  */
20404                                                          return 92;
20405                                                        }
20406                                                      else
20407                                                        {
20408                                                          /* 33222222222211111111110000000000
20409                                                             10987654321098765432109876543210
20410                                                             x1101110xx1xxxxx100000xxxxxxxxxx
20411                                                             umlal2.  */
20412                                                          return 93;
20413                                                        }
20414                                                    }
20415                                                }
20416                                              else
20417                                                {
20418                                                  if (((word >> 29) & 0x1) == 0)
20419                                                    {
20420                                                      if (((word >> 30) & 0x1) == 0)
20421                                                        {
20422                                                          /* 33222222222211111111110000000000
20423                                                             10987654321098765432109876543210
20424                                                             x0001110xx1xxxxx110000xxxxxxxxxx
20425                                                             smull.  */
20426                                                          return 68;
20427                                                        }
20428                                                      else
20429                                                        {
20430                                                          if (((word >> 31) & 0x1) == 0)
20431                                                            {
20432                                                              /* 33222222222211111111110000000000
20433                                                                 10987654321098765432109876543210
20434                                                                 01001110xx1xxxxx110000xxxxxxxxxx
20435                                                                 smull2.  */
20436                                                              return 69;
20437                                                            }
20438                                                          else
20439                                                            {
20440                                                              /* 33222222222211111111110000000000
20441                                                                 10987654321098765432109876543210
20442                                                                 11001110xx1xxxxx110000xxxxxxxxxx
20443                                                                 sm3partw1.  */
20444                                                              return 2431;
20445                                                            }
20446                                                        }
20447                                                    }
20448                                                  else
20449                                                    {
20450                                                      if (((word >> 30) & 0x1) == 0)
20451                                                        {
20452                                                          /* 33222222222211111111110000000000
20453                                                             10987654321098765432109876543210
20454                                                             x0101110xx1xxxxx110000xxxxxxxxxx
20455                                                             umull.  */
20456                                                          return 96;
20457                                                        }
20458                                                      else
20459                                                        {
20460                                                          /* 33222222222211111111110000000000
20461                                                             10987654321098765432109876543210
20462                                                             x1101110xx1xxxxx110000xxxxxxxxxx
20463                                                             umull2.  */
20464                                                          return 97;
20465                                                        }
20466                                                    }
20467                                                }
20468                                            }
20469                                          else
20470                                            {
20471                                              if (((word >> 14) & 0x1) == 0)
20472                                                {
20473                                                  if (((word >> 29) & 0x1) == 0)
20474                                                    {
20475                                                      if (((word >> 30) & 0x1) == 0)
20476                                                        {
20477                                                          /* 33222222222211111111110000000000
20478                                                             10987654321098765432109876543210
20479                                                             x0001110xx1xxxxx101000xxxxxxxxxx
20480                                                             smlsl.  */
20481                                                          return 64;
20482                                                        }
20483                                                      else
20484                                                        {
20485                                                          /* 33222222222211111111110000000000
20486                                                             10987654321098765432109876543210
20487                                                             x1001110xx1xxxxx101000xxxxxxxxxx
20488                                                             smlsl2.  */
20489                                                          return 65;
20490                                                        }
20491                                                    }
20492                                                  else
20493                                                    {
20494                                                      if (((word >> 30) & 0x1) == 0)
20495                                                        {
20496                                                          /* 33222222222211111111110000000000
20497                                                             10987654321098765432109876543210
20498                                                             x0101110xx1xxxxx101000xxxxxxxxxx
20499                                                             umlsl.  */
20500                                                          return 94;
20501                                                        }
20502                                                      else
20503                                                        {
20504                                                          /* 33222222222211111111110000000000
20505                                                             10987654321098765432109876543210
20506                                                             x1101110xx1xxxxx101000xxxxxxxxxx
20507                                                             umlsl2.  */
20508                                                          return 95;
20509                                                        }
20510                                                    }
20511                                                }
20512                                              else
20513                                                {
20514                                                  if (((word >> 22) & 0x1) == 0)
20515                                                    {
20516                                                      if (((word >> 30) & 0x1) == 0)
20517                                                        {
20518                                                          /* 33222222222211111111110000000000
20519                                                             10987654321098765432109876543210
20520                                                             x0x01110x01xxxxx111000xxxxxxxxxx
20521                                                             pmull.  */
20522                                                          return 72;
20523                                                        }
20524                                                      else
20525                                                        {
20526                                                          /* 33222222222211111111110000000000
20527                                                             10987654321098765432109876543210
20528                                                             x1x01110x01xxxxx111000xxxxxxxxxx
20529                                                             pmull2.  */
20530                                                          return 74;
20531                                                        }
20532                                                    }
20533                                                  else
20534                                                    {
20535                                                      if (((word >> 30) & 0x1) == 0)
20536                                                        {
20537                                                          /* 33222222222211111111110000000000
20538                                                             10987654321098765432109876543210
20539                                                             x0x01110x11xxxxx111000xxxxxxxxxx
20540                                                             pmull.  */
20541                                                          return 73;
20542                                                        }
20543                                                      else
20544                                                        {
20545                                                          /* 33222222222211111111110000000000
20546                                                             10987654321098765432109876543210
20547                                                             x1x01110x11xxxxx111000xxxxxxxxxx
20548                                                             pmull2.  */
20549                                                          return 75;
20550                                                        }
20551                                                    }
20552                                                }
20553                                            }
20554                                        }
20555                                      else
20556                                        {
20557                                          if (((word >> 13) & 0x1) == 0)
20558                                            {
20559                                              if (((word >> 14) & 0x1) == 0)
20560                                                {
20561                                                  if (((word >> 30) & 0x1) == 0)
20562                                                    {
20563                                                      /* 33222222222211111111110000000000
20564                                                         10987654321098765432109876543210
20565                                                         x0x01110xx1xxxxx100100xxxxxxxxxx
20566                                                         sqdmlal.  */
20567                                                      return 62;
20568                                                    }
20569                                                  else
20570                                                    {
20571                                                      /* 33222222222211111111110000000000
20572                                                         10987654321098765432109876543210
20573                                                         x1x01110xx1xxxxx100100xxxxxxxxxx
20574                                                         sqdmlal2.  */
20575                                                      return 63;
20576                                                    }
20577                                                }
20578                                              else
20579                                                {
20580                                                  if (((word >> 30) & 0x1) == 0)
20581                                                    {
20582                                                      /* 33222222222211111111110000000000
20583                                                         10987654321098765432109876543210
20584                                                         x0x01110xx1xxxxx110100xxxxxxxxxx
20585                                                         sqdmull.  */
20586                                                      return 70;
20587                                                    }
20588                                                  else
20589                                                    {
20590                                                      /* 33222222222211111111110000000000
20591                                                         10987654321098765432109876543210
20592                                                         x1x01110xx1xxxxx110100xxxxxxxxxx
20593                                                         sqdmull2.  */
20594                                                      return 71;
20595                                                    }
20596                                                }
20597                                            }
20598                                          else
20599                                            {
20600                                              if (((word >> 30) & 0x1) == 0)
20601                                                {
20602                                                  /* 33222222222211111111110000000000
20603                                                     10987654321098765432109876543210
20604                                                     x0x01110xx1xxxxx1x1100xxxxxxxxxx
20605                                                     sqdmlsl.  */
20606                                                  return 66;
20607                                                }
20608                                              else
20609                                                {
20610                                                  /* 33222222222211111111110000000000
20611                                                     10987654321098765432109876543210
20612                                                     x1x01110xx1xxxxx1x1100xxxxxxxxxx
20613                                                     sqdmlsl2.  */
20614                                                  return 67;
20615                                                }
20616                                            }
20617                                        }
20618                                    }
20619                                  else
20620                                    {
20621                                      if (((word >> 12) & 0x1) == 0)
20622                                        {
20623                                          if (((word >> 13) & 0x1) == 0)
20624                                            {
20625                                              if (((word >> 14) & 0x1) == 0)
20626                                                {
20627                                                  if (((word >> 29) & 0x1) == 0)
20628                                                    {
20629                                                      if (((word >> 31) & 0x1) == 0)
20630                                                        {
20631                                                          if (((word >> 16) & 0x1) == 0)
20632                                                            {
20633                                                              /* 33222222222211111111110000000000
20634                                                                 10987654321098765432109876543210
20635                                                                 0x001110xx1xxxx0100010xxxxxxxxxx
20636                                                                 cmgt.  */
20637                                                              return 170;
20638                                                            }
20639                                                          else
20640                                                            {
20641                                                              if (((word >> 19) & 0x1) == 0)
20642                                                                {
20643                                                                  if (((word >> 23) & 0x1) == 0)
20644                                                                    {
20645                                                                      /* 33222222222211111111110000000000
20646                                                                         10987654321098765432109876543210
20647                                                                         0x0011100x1x0xx1100010xxxxxxxxxx
20648                                                                         frintn.  */
20649                                                                      return 182;
20650                                                                    }
20651                                                                  else
20652                                                                    {
20653                                                                      /* 33222222222211111111110000000000
20654                                                                         10987654321098765432109876543210
20655                                                                         0x0011101x1x0xx1100010xxxxxxxxxx
20656                                                                         frintp.  */
20657                                                                      return 202;
20658                                                                    }
20659                                                                }
20660                                                              else
20661                                                                {
20662                                                                  if (((word >> 23) & 0x1) == 0)
20663                                                                    {
20664                                                                      /* 33222222222211111111110000000000
20665                                                                         10987654321098765432109876543210
20666                                                                         0x0011100x1x1xx1100010xxxxxxxxxx
20667                                                                         frintn.  */
20668                                                                      return 183;
20669                                                                    }
20670                                                                  else
20671                                                                    {
20672                                                                      /* 33222222222211111111110000000000
20673                                                                         10987654321098765432109876543210
20674                                                                         0x0011101x1x1xx1100010xxxxxxxxxx
20675                                                                         frintp.  */
20676                                                                      return 203;
20677                                                                    }
20678                                                                }
20679                                                            }
20680                                                        }
20681                                                      else
20682                                                        {
20683                                                          /* 33222222222211111111110000000000
20684                                                             10987654321098765432109876543210
20685                                                             1x001110xx1xxxxx100010xxxxxxxxxx
20686                                                             sha512su1.  */
20687                                                          return 2421;
20688                                                        }
20689                                                    }
20690                                                  else
20691                                                    {
20692                                                      if (((word >> 16) & 0x1) == 0)
20693                                                        {
20694                                                          /* 33222222222211111111110000000000
20695                                                             10987654321098765432109876543210
20696                                                             xx101110xx1xxxx0100010xxxxxxxxxx
20697                                                             cmge.  */
20698                                                          return 219;
20699                                                        }
20700                                                      else
20701                                                        {
20702                                                          if (((word >> 19) & 0x1) == 0)
20703                                                            {
20704                                                              /* 33222222222211111111110000000000
20705                                                                 10987654321098765432109876543210
20706                                                                 xx101110xx1x0xx1100010xxxxxxxxxx
20707                                                                 frinta.  */
20708                                                              return 230;
20709                                                            }
20710                                                          else
20711                                                            {
20712                                                              /* 33222222222211111111110000000000
20713                                                                 10987654321098765432109876543210
20714                                                                 xx101110xx1x1xx1100010xxxxxxxxxx
20715                                                                 frinta.  */
20716                                                              return 231;
20717                                                            }
20718                                                        }
20719                                                    }
20720                                                }
20721                                              else
20722                                                {
20723                                                  if (((word >> 23) & 0x1) == 0)
20724                                                    {
20725                                                      if (((word >> 29) & 0x1) == 0)
20726                                                        {
20727                                                          if (((word >> 31) & 0x1) == 0)
20728                                                            {
20729                                                              if (((word >> 16) & 0x1) == 0)
20730                                                                {
20731                                                                  /* 33222222222211111111110000000000
20732                                                                     10987654321098765432109876543210
20733                                                                     0x0011100x1xxxx0110010xxxxxxxxxx
20734                                                                     fmaxnmv.  */
20735                                                                  return 37;
20736                                                                }
20737                                                              else
20738                                                                {
20739                                                                  if (((word >> 19) & 0x1) == 0)
20740                                                                    {
20741                                                                      /* 33222222222211111111110000000000
20742                                                                         10987654321098765432109876543210
20743                                                                         0x0011100x1x0xx1110010xxxxxxxxxx
20744                                                                         fcvtas.  */
20745                                                                      return 190;
20746                                                                    }
20747                                                                  else
20748                                                                    {
20749                                                                      /* 33222222222211111111110000000000
20750                                                                         10987654321098765432109876543210
20751                                                                         0x0011100x1x1xx1110010xxxxxxxxxx
20752                                                                         fcvtas.  */
20753                                                                      return 191;
20754                                                                    }
20755                                                                }
20756                                                            }
20757                                                          else
20758                                                            {
20759                                                              /* 33222222222211111111110000000000
20760                                                                 10987654321098765432109876543210
20761                                                                 1x0011100x1xxxxx110010xxxxxxxxxx
20762                                                                 sm4ekey.  */
20763                                                              return 2434;
20764                                                            }
20765                                                        }
20766                                                      else
20767                                                        {
20768                                                          if (((word >> 16) & 0x1) == 0)
20769                                                            {
20770                                                              /* 33222222222211111111110000000000
20771                                                                 10987654321098765432109876543210
20772                                                                 xx1011100x1xxxx0110010xxxxxxxxxx
20773                                                                 fmaxnmv.  */
20774                                                              return 36;
20775                                                            }
20776                                                          else
20777                                                            {
20778                                                              if (((word >> 19) & 0x1) == 0)
20779                                                                {
20780                                                                  /* 33222222222211111111110000000000
20781                                                                     10987654321098765432109876543210
20782                                                                     xx1011100x1x0xx1110010xxxxxxxxxx
20783                                                                     fcvtau.  */
20784                                                                  return 238;
20785                                                                }
20786                                                              else
20787                                                                {
20788                                                                  /* 33222222222211111111110000000000
20789                                                                     10987654321098765432109876543210
20790                                                                     xx1011100x1x1xx1110010xxxxxxxxxx
20791                                                                     fcvtau.  */
20792                                                                  return 239;
20793                                                                }
20794                                                            }
20795                                                        }
20796                                                    }
20797                                                  else
20798                                                    {
20799                                                      if (((word >> 16) & 0x1) == 0)
20800                                                        {
20801                                                          if (((word >> 19) & 0x1) == 0)
20802                                                            {
20803                                                              if (((word >> 20) & 0x1) == 0)
20804                                                                {
20805                                                                  if (((word >> 29) & 0x1) == 0)
20806                                                                    {
20807                                                                      /* 33222222222211111111110000000000
20808                                                                         10987654321098765432109876543210
20809                                                                         xx0011101x100xx0110010xxxxxxxxxx
20810                                                                         fcmgt.  */
20811                                                                      return 194;
20812                                                                    }
20813                                                                  else
20814                                                                    {
20815                                                                      /* 33222222222211111111110000000000
20816                                                                         10987654321098765432109876543210
20817                                                                         xx1011101x100xx0110010xxxxxxxxxx
20818                                                                         fcmge.  */
20819                                                                      return 245;
20820                                                                    }
20821                                                                }
20822                                                              else
20823                                                                {
20824                                                                  if (((word >> 29) & 0x1) == 0)
20825                                                                    {
20826                                                                      /* 33222222222211111111110000000000
20827                                                                         10987654321098765432109876543210
20828                                                                         xx0011101x110xx0110010xxxxxxxxxx
20829                                                                         fminnmv.  */
20830                                                                      return 41;
20831                                                                    }
20832                                                                  else
20833                                                                    {
20834                                                                      /* 33222222222211111111110000000000
20835                                                                         10987654321098765432109876543210
20836                                                                         xx1011101x110xx0110010xxxxxxxxxx
20837                                                                         fminnmv.  */
20838                                                                      return 40;
20839                                                                    }
20840                                                                }
20841                                                            }
20842                                                          else
20843                                                            {
20844                                                              if (((word >> 29) & 0x1) == 0)
20845                                                                {
20846                                                                  /* 33222222222211111111110000000000
20847                                                                     10987654321098765432109876543210
20848                                                                     xx0011101x1x1xx0110010xxxxxxxxxx
20849                                                                     fcmgt.  */
20850                                                                  return 195;
20851                                                                }
20852                                                              else
20853                                                                {
20854                                                                  /* 33222222222211111111110000000000
20855                                                                     10987654321098765432109876543210
20856                                                                     xx1011101x1x1xx0110010xxxxxxxxxx
20857                                                                     fcmge.  */
20858                                                                  return 246;
20859                                                                }
20860                                                            }
20861                                                        }
20862                                                      else
20863                                                        {
20864                                                          if (((word >> 29) & 0x1) == 0)
20865                                                            {
20866                                                              /* 33222222222211111111110000000000
20867                                                                 10987654321098765432109876543210
20868                                                                 xx0011101x1xxxx1110010xxxxxxxxxx
20869                                                                 urecpe.  */
20870                                                              return 210;
20871                                                            }
20872                                                          else
20873                                                            {
20874                                                              /* 33222222222211111111110000000000
20875                                                                 10987654321098765432109876543210
20876                                                                 xx1011101x1xxxx1110010xxxxxxxxxx
20877                                                                 ursqrte.  */
20878                                                              return 257;
20879                                                            }
20880                                                        }
20881                                                    }
20882                                                }
20883                                            }
20884                                          else
20885                                            {
20886                                              if (((word >> 14) & 0x1) == 0)
20887                                                {
20888                                                  if (((word >> 16) & 0x1) == 0)
20889                                                    {
20890                                                      if (((word >> 20) & 0x1) == 0)
20891                                                        {
20892                                                          /* 33222222222211111111110000000000
20893                                                             10987654321098765432109876543210
20894                                                             xxx01110xx10xxx0101010xxxxxxxxxx
20895                                                             cmlt.  */
20896                                                          return 172;
20897                                                        }
20898                                                      else
20899                                                        {
20900                                                          if (((word >> 29) & 0x1) == 0)
20901                                                            {
20902                                                              /* 33222222222211111111110000000000
20903                                                                 10987654321098765432109876543210
20904                                                                 xx001110xx11xxx0101010xxxxxxxxxx
20905                                                                 smaxv.  */
20906                                                              return 30;
20907                                                            }
20908                                                          else
20909                                                            {
20910                                                              /* 33222222222211111111110000000000
20911                                                                 10987654321098765432109876543210
20912                                                                 xx101110xx11xxx0101010xxxxxxxxxx
20913                                                                 umaxv.  */
20914                                                              return 34;
20915                                                            }
20916                                                        }
20917                                                    }
20918                                                  else
20919                                                    {
20920                                                      if (((word >> 19) & 0x1) == 0)
20921                                                        {
20922                                                          if (((word >> 20) & 0x1) == 0)
20923                                                            {
20924                                                              if (((word >> 23) & 0x1) == 0)
20925                                                                {
20926                                                                  if (((word >> 29) & 0x1) == 0)
20927                                                                    {
20928                                                                      /* 33222222222211111111110000000000
20929                                                                         10987654321098765432109876543210
20930                                                                         xx0011100x100xx1101010xxxxxxxxxx
20931                                                                         fcvtns.  */
20932                                                                      return 186;
20933                                                                    }
20934                                                                  else
20935                                                                    {
20936                                                                      /* 33222222222211111111110000000000
20937                                                                         10987654321098765432109876543210
20938                                                                         xx1011100x100xx1101010xxxxxxxxxx
20939                                                                         fcvtnu.  */
20940                                                                      return 234;
20941                                                                    }
20942                                                                }
20943                                                              else
20944                                                                {
20945                                                                  if (((word >> 29) & 0x1) == 0)
20946                                                                    {
20947                                                                      /* 33222222222211111111110000000000
20948                                                                         10987654321098765432109876543210
20949                                                                         xx0011101x100xx1101010xxxxxxxxxx
20950                                                                         fcvtps.  */
20951                                                                      return 206;
20952                                                                    }
20953                                                                  else
20954                                                                    {
20955                                                                      /* 33222222222211111111110000000000
20956                                                                         10987654321098765432109876543210
20957                                                                         xx1011101x100xx1101010xxxxxxxxxx
20958                                                                         fcvtpu.  */
20959                                                                      return 253;
20960                                                                    }
20961                                                                }
20962                                                            }
20963                                                          else
20964                                                            {
20965                                                              if (((word >> 29) & 0x1) == 0)
20966                                                                {
20967                                                                  /* 33222222222211111111110000000000
20968                                                                     10987654321098765432109876543210
20969                                                                     xx001110xx110xx1101010xxxxxxxxxx
20970                                                                     sminv.  */
20971                                                                  return 31;
20972                                                                }
20973                                                              else
20974                                                                {
20975                                                                  /* 33222222222211111111110000000000
20976                                                                     10987654321098765432109876543210
20977                                                                     xx101110xx110xx1101010xxxxxxxxxx
20978                                                                     uminv.  */
20979                                                                  return 35;
20980                                                                }
20981                                                            }
20982                                                        }
20983                                                      else
20984                                                        {
20985                                                          if (((word >> 23) & 0x1) == 0)
20986                                                            {
20987                                                              if (((word >> 29) & 0x1) == 0)
20988                                                                {
20989                                                                  /* 33222222222211111111110000000000
20990                                                                     10987654321098765432109876543210
20991                                                                     xx0011100x1x1xx1101010xxxxxxxxxx
20992                                                                     fcvtns.  */
20993                                                                  return 187;
20994                                                                }
20995                                                              else
20996                                                                {
20997                                                                  /* 33222222222211111111110000000000
20998                                                                     10987654321098765432109876543210
20999                                                                     xx1011100x1x1xx1101010xxxxxxxxxx
21000                                                                     fcvtnu.  */
21001                                                                  return 235;
21002                                                                }
21003                                                            }
21004                                                          else
21005                                                            {
21006                                                              if (((word >> 29) & 0x1) == 0)
21007                                                                {
21008                                                                  /* 33222222222211111111110000000000
21009                                                                     10987654321098765432109876543210
21010                                                                     xx0011101x1x1xx1101010xxxxxxxxxx
21011                                                                     fcvtps.  */
21012                                                                  return 207;
21013                                                                }
21014                                                              else
21015                                                                {
21016                                                                  /* 33222222222211111111110000000000
21017                                                                     10987654321098765432109876543210
21018                                                                     xx1011101x1x1xx1101010xxxxxxxxxx
21019                                                                     fcvtpu.  */
21020                                                                  return 254;
21021                                                                }
21022                                                            }
21023                                                        }
21024                                                    }
21025                                                }
21026                                              else
21027                                                {
21028                                                  if (((word >> 16) & 0x1) == 0)
21029                                                    {
21030                                                      if (((word >> 19) & 0x1) == 0)
21031                                                        {
21032                                                          /* 33222222222211111111110000000000
21033                                                             10987654321098765432109876543210
21034                                                             xxx01110xx1x0xx0111010xxxxxxxxxx
21035                                                             fcmlt.  */
21036                                                          return 198;
21037                                                        }
21038                                                      else
21039                                                        {
21040                                                          /* 33222222222211111111110000000000
21041                                                             10987654321098765432109876543210
21042                                                             xxx01110xx1x1xx0111010xxxxxxxxxx
21043                                                             fcmlt.  */
21044                                                          return 199;
21045                                                        }
21046                                                    }
21047                                                  else
21048                                                    {
21049                                                      if (((word >> 29) & 0x1) == 0)
21050                                                        {
21051                                                          /* 33222222222211111111110000000000
21052                                                             10987654321098765432109876543210
21053                                                             xx001110xx1xxxx1111010xxxxxxxxxx
21054                                                             frint32z.  */
21055                                                          return 158;
21056                                                        }
21057                                                      else
21058                                                        {
21059                                                          /* 33222222222211111111110000000000
21060                                                             10987654321098765432109876543210
21061                                                             xx101110xx1xxxx1111010xxxxxxxxxx
21062                                                             frint32x.  */
21063                                                          return 159;
21064                                                        }
21065                                                    }
21066                                                }
21067                                            }
21068                                        }
21069                                      else
21070                                        {
21071                                          if (((word >> 13) & 0x1) == 0)
21072                                            {
21073                                              if (((word >> 14) & 0x1) == 0)
21074                                                {
21075                                                  if (((word >> 16) & 0x1) == 0)
21076                                                    {
21077                                                      if (((word >> 29) & 0x1) == 0)
21078                                                        {
21079                                                          /* 33222222222211111111110000000000
21080                                                             10987654321098765432109876543210
21081                                                             xx001110xx1xxxx0100110xxxxxxxxxx
21082                                                             cmeq.  */
21083                                                          return 171;
21084                                                        }
21085                                                      else
21086                                                        {
21087                                                          /* 33222222222211111111110000000000
21088                                                             10987654321098765432109876543210
21089                                                             xx101110xx1xxxx0100110xxxxxxxxxx
21090                                                             cmle.  */
21091                                                          return 220;
21092                                                        }
21093                                                    }
21094                                                  else
21095                                                    {
21096                                                      if (((word >> 19) & 0x1) == 0)
21097                                                        {
21098                                                          if (((word >> 23) & 0x1) == 0)
21099                                                            {
21100                                                              if (((word >> 29) & 0x1) == 0)
21101                                                                {
21102                                                                  /* 33222222222211111111110000000000
21103                                                                     10987654321098765432109876543210
21104                                                                     xx0011100x1x0xx1100110xxxxxxxxxx
21105                                                                     frintm.  */
21106                                                                  return 184;
21107                                                                }
21108                                                              else
21109                                                                {
21110                                                                  /* 33222222222211111111110000000000
21111                                                                     10987654321098765432109876543210
21112                                                                     xx1011100x1x0xx1100110xxxxxxxxxx
21113                                                                     frintx.  */
21114                                                                  return 232;
21115                                                                }
21116                                                            }
21117                                                          else
21118                                                            {
21119                                                              if (((word >> 29) & 0x1) == 0)
21120                                                                {
21121                                                                  /* 33222222222211111111110000000000
21122                                                                     10987654321098765432109876543210
21123                                                                     xx0011101x1x0xx1100110xxxxxxxxxx
21124                                                                     frintz.  */
21125                                                                  return 204;
21126                                                                }
21127                                                              else
21128                                                                {
21129                                                                  /* 33222222222211111111110000000000
21130                                                                     10987654321098765432109876543210
21131                                                                     xx1011101x1x0xx1100110xxxxxxxxxx
21132                                                                     frinti.  */
21133                                                                  return 251;
21134                                                                }
21135                                                            }
21136                                                        }
21137                                                      else
21138                                                        {
21139                                                          if (((word >> 23) & 0x1) == 0)
21140                                                            {
21141                                                              if (((word >> 29) & 0x1) == 0)
21142                                                                {
21143                                                                  /* 33222222222211111111110000000000
21144                                                                     10987654321098765432109876543210
21145                                                                     xx0011100x1x1xx1100110xxxxxxxxxx
21146                                                                     frintm.  */
21147                                                                  return 185;
21148                                                                }
21149                                                              else
21150                                                                {
21151                                                                  /* 33222222222211111111110000000000
21152                                                                     10987654321098765432109876543210
21153                                                                     xx1011100x1x1xx1100110xxxxxxxxxx
21154                                                                     frintx.  */
21155                                                                  return 233;
21156                                                                }
21157                                                            }
21158                                                          else
21159                                                            {
21160                                                              if (((word >> 29) & 0x1) == 0)
21161                                                                {
21162                                                                  /* 33222222222211111111110000000000
21163                                                                     10987654321098765432109876543210
21164                                                                     xx0011101x1x1xx1100110xxxxxxxxxx
21165                                                                     frintz.  */
21166                                                                  return 205;
21167                                                                }
21168                                                              else
21169                                                                {
21170                                                                  /* 33222222222211111111110000000000
21171                                                                     10987654321098765432109876543210
21172                                                                     xx1011101x1x1xx1100110xxxxxxxxxx
21173                                                                     frinti.  */
21174                                                                  return 252;
21175                                                                }
21176                                                            }
21177                                                        }
21178                                                    }
21179                                                }
21180                                              else
21181                                                {
21182                                                  if (((word >> 16) & 0x1) == 0)
21183                                                    {
21184                                                      if (((word >> 19) & 0x1) == 0)
21185                                                        {
21186                                                          if (((word >> 29) & 0x1) == 0)
21187                                                            {
21188                                                              /* 33222222222211111111110000000000
21189                                                                 10987654321098765432109876543210
21190                                                                 xx001110xx1x0xx0110110xxxxxxxxxx
21191                                                                 fcmeq.  */
21192                                                              return 196;
21193                                                            }
21194                                                          else
21195                                                            {
21196                                                              /* 33222222222211111111110000000000
21197                                                                 10987654321098765432109876543210
21198                                                                 xx101110xx1x0xx0110110xxxxxxxxxx
21199                                                                 fcmle.  */
21200                                                              return 247;
21201                                                            }
21202                                                        }
21203                                                      else
21204                                                        {
21205                                                          if (((word >> 29) & 0x1) == 0)
21206                                                            {
21207                                                              /* 33222222222211111111110000000000
21208                                                                 10987654321098765432109876543210
21209                                                                 xx001110xx1x1xx0110110xxxxxxxxxx
21210                                                                 fcmeq.  */
21211                                                              return 197;
21212                                                            }
21213                                                          else
21214                                                            {
21215                                                              /* 33222222222211111111110000000000
21216                                                                 10987654321098765432109876543210
21217                                                                 xx101110xx1x1xx0110110xxxxxxxxxx
21218                                                                 fcmle.  */
21219                                                              return 248;
21220                                                            }
21221                                                        }
21222                                                    }
21223                                                  else
21224                                                    {
21225                                                      if (((word >> 19) & 0x1) == 0)
21226                                                        {
21227                                                          if (((word >> 23) & 0x1) == 0)
21228                                                            {
21229                                                              if (((word >> 29) & 0x1) == 0)
21230                                                                {
21231                                                                  /* 33222222222211111111110000000000
21232                                                                     10987654321098765432109876543210
21233                                                                     xx0011100x1x0xx1110110xxxxxxxxxx
21234                                                                     scvtf.  */
21235                                                                  return 192;
21236                                                                }
21237                                                              else
21238                                                                {
21239                                                                  /* 33222222222211111111110000000000
21240                                                                     10987654321098765432109876543210
21241                                                                     xx1011100x1x0xx1110110xxxxxxxxxx
21242                                                                     ucvtf.  */
21243                                                                  return 240;
21244                                                                }
21245                                                            }
21246                                                          else
21247                                                            {
21248                                                              if (((word >> 29) & 0x1) == 0)
21249                                                                {
21250                                                                  /* 33222222222211111111110000000000
21251                                                                     10987654321098765432109876543210
21252                                                                     xx0011101x1x0xx1110110xxxxxxxxxx
21253                                                                     frecpe.  */
21254                                                                  return 211;
21255                                                                }
21256                                                              else
21257                                                                {
21258                                                                  /* 33222222222211111111110000000000
21259                                                                     10987654321098765432109876543210
21260                                                                     xx1011101x1x0xx1110110xxxxxxxxxx
21261                                                                     frsqrte.  */
21262                                                                  return 258;
21263                                                                }
21264                                                            }
21265                                                        }
21266                                                      else
21267                                                        {
21268                                                          if (((word >> 23) & 0x1) == 0)
21269                                                            {
21270                                                              if (((word >> 29) & 0x1) == 0)
21271                                                                {
21272                                                                  /* 33222222222211111111110000000000
21273                                                                     10987654321098765432109876543210
21274                                                                     xx0011100x1x1xx1110110xxxxxxxxxx
21275                                                                     scvtf.  */
21276                                                                  return 193;
21277                                                                }
21278                                                              else
21279                                                                {
21280                                                                  /* 33222222222211111111110000000000
21281                                                                     10987654321098765432109876543210
21282                                                                     xx1011100x1x1xx1110110xxxxxxxxxx
21283                                                                     ucvtf.  */
21284                                                                  return 241;
21285                                                                }
21286                                                            }
21287                                                          else
21288                                                            {
21289                                                              if (((word >> 29) & 0x1) == 0)
21290                                                                {
21291                                                                  /* 33222222222211111111110000000000
21292                                                                     10987654321098765432109876543210
21293                                                                     xx0011101x1x1xx1110110xxxxxxxxxx
21294                                                                     frecpe.  */
21295                                                                  return 212;
21296                                                                }
21297                                                              else
21298                                                                {
21299                                                                  /* 33222222222211111111110000000000
21300                                                                     10987654321098765432109876543210
21301                                                                     xx1011101x1x1xx1110110xxxxxxxxxx
21302                                                                     frsqrte.  */
21303                                                                  return 259;
21304                                                                }
21305                                                            }
21306                                                        }
21307                                                    }
21308                                                }
21309                                            }
21310                                          else
21311                                            {
21312                                              if (((word >> 14) & 0x1) == 0)
21313                                                {
21314                                                  if (((word >> 16) & 0x1) == 0)
21315                                                    {
21316                                                      if (((word >> 29) & 0x1) == 0)
21317                                                        {
21318                                                          /* 33222222222211111111110000000000
21319                                                             10987654321098765432109876543210
21320                                                             xx001110xx1xxxx0101110xxxxxxxxxx
21321                                                             abs.  */
21322                                                          return 173;
21323                                                        }
21324                                                      else
21325                                                        {
21326                                                          /* 33222222222211111111110000000000
21327                                                             10987654321098765432109876543210
21328                                                             xx101110xx1xxxx0101110xxxxxxxxxx
21329                                                             neg.  */
21330                                                          return 221;
21331                                                        }
21332                                                    }
21333                                                  else
21334                                                    {
21335                                                      if (((word >> 19) & 0x1) == 0)
21336                                                        {
21337                                                          if (((word >> 20) & 0x1) == 0)
21338                                                            {
21339                                                              if (((word >> 23) & 0x1) == 0)
21340                                                                {
21341                                                                  if (((word >> 29) & 0x1) == 0)
21342                                                                    {
21343                                                                      /* 33222222222211111111110000000000
21344                                                                         10987654321098765432109876543210
21345                                                                         xx0011100x100xx1101110xxxxxxxxxx
21346                                                                         fcvtms.  */
21347                                                                      return 188;
21348                                                                    }
21349                                                                  else
21350                                                                    {
21351                                                                      /* 33222222222211111111110000000000
21352                                                                         10987654321098765432109876543210
21353                                                                         xx1011100x100xx1101110xxxxxxxxxx
21354                                                                         fcvtmu.  */
21355                                                                      return 236;
21356                                                                    }
21357                                                                }
21358                                                              else
21359                                                                {
21360                                                                  if (((word >> 29) & 0x1) == 0)
21361                                                                    {
21362                                                                      /* 33222222222211111111110000000000
21363                                                                         10987654321098765432109876543210
21364                                                                         xx0011101x100xx1101110xxxxxxxxxx
21365                                                                         fcvtzs.  */
21366                                                                      return 208;
21367                                                                    }
21368                                                                  else
21369                                                                    {
21370                                                                      /* 33222222222211111111110000000000
21371                                                                         10987654321098765432109876543210
21372                                                                         xx1011101x100xx1101110xxxxxxxxxx
21373                                                                         fcvtzu.  */
21374                                                                      return 255;
21375                                                                    }
21376                                                                }
21377                                                            }
21378                                                          else
21379                                                            {
21380                                                              /* 33222222222211111111110000000000
21381                                                                 10987654321098765432109876543210
21382                                                                 xxx01110xx110xx1101110xxxxxxxxxx
21383                                                                 addv.  */
21384                                                              return 32;
21385                                                            }
21386                                                        }
21387                                                      else
21388                                                        {
21389                                                          if (((word >> 23) & 0x1) == 0)
21390                                                            {
21391                                                              if (((word >> 29) & 0x1) == 0)
21392                                                                {
21393                                                                  /* 33222222222211111111110000000000
21394                                                                     10987654321098765432109876543210
21395                                                                     xx0011100x1x1xx1101110xxxxxxxxxx
21396                                                                     fcvtms.  */
21397                                                                  return 189;
21398                                                                }
21399                                                              else
21400                                                                {
21401                                                                  /* 33222222222211111111110000000000
21402                                                                     10987654321098765432109876543210
21403                                                                     xx1011100x1x1xx1101110xxxxxxxxxx
21404                                                                     fcvtmu.  */
21405                                                                  return 237;
21406                                                                }
21407                                                            }
21408                                                          else
21409                                                            {
21410                                                              if (((word >> 29) & 0x1) == 0)
21411                                                                {
21412                                                                  /* 33222222222211111111110000000000
21413                                                                     10987654321098765432109876543210
21414                                                                     xx0011101x1x1xx1101110xxxxxxxxxx
21415                                                                     fcvtzs.  */
21416                                                                  return 209;
21417                                                                }
21418                                                              else
21419                                                                {
21420                                                                  /* 33222222222211111111110000000000
21421                                                                     10987654321098765432109876543210
21422                                                                     xx1011101x1x1xx1101110xxxxxxxxxx
21423                                                                     fcvtzu.  */
21424                                                                  return 256;
21425                                                                }
21426                                                            }
21427                                                        }
21428                                                    }
21429                                                }
21430                                              else
21431                                                {
21432                                                  if (((word >> 16) & 0x1) == 0)
21433                                                    {
21434                                                      if (((word >> 19) & 0x1) == 0)
21435                                                        {
21436                                                          if (((word >> 20) & 0x1) == 0)
21437                                                            {
21438                                                              if (((word >> 29) & 0x1) == 0)
21439                                                                {
21440                                                                  /* 33222222222211111111110000000000
21441                                                                     10987654321098765432109876543210
21442                                                                     xx001110xx100xx0111110xxxxxxxxxx
21443                                                                     fabs.  */
21444                                                                  return 200;
21445                                                                }
21446                                                              else
21447                                                                {
21448                                                                  /* 33222222222211111111110000000000
21449                                                                     10987654321098765432109876543210
21450                                                                     xx101110xx100xx0111110xxxxxxxxxx
21451                                                                     fneg.  */
21452                                                                  return 249;
21453                                                                }
21454                                                            }
21455                                                          else
21456                                                            {
21457                                                              if (((word >> 23) & 0x1) == 0)
21458                                                                {
21459                                                                  if (((word >> 29) & 0x1) == 0)
21460                                                                    {
21461                                                                      /* 33222222222211111111110000000000
21462                                                                         10987654321098765432109876543210
21463                                                                         xx0011100x110xx0111110xxxxxxxxxx
21464                                                                         fmaxv.  */
21465                                                                      return 39;
21466                                                                    }
21467                                                                  else
21468                                                                    {
21469                                                                      /* 33222222222211111111110000000000
21470                                                                         10987654321098765432109876543210
21471                                                                         xx1011100x110xx0111110xxxxxxxxxx
21472                                                                         fmaxv.  */
21473                                                                      return 38;
21474                                                                    }
21475                                                                }
21476                                                              else
21477                                                                {
21478                                                                  if (((word >> 29) & 0x1) == 0)
21479                                                                    {
21480                                                                      /* 33222222222211111111110000000000
21481                                                                         10987654321098765432109876543210
21482                                                                         xx0011101x110xx0111110xxxxxxxxxx
21483                                                                         fminv.  */
21484                                                                      return 43;
21485                                                                    }
21486                                                                  else
21487                                                                    {
21488                                                                      /* 33222222222211111111110000000000
21489                                                                         10987654321098765432109876543210
21490                                                                         xx1011101x110xx0111110xxxxxxxxxx
21491                                                                         fminv.  */
21492                                                                      return 42;
21493                                                                    }
21494                                                                }
21495                                                            }
21496                                                        }
21497                                                      else
21498                                                        {
21499                                                          if (((word >> 29) & 0x1) == 0)
21500                                                            {
21501                                                              /* 33222222222211111111110000000000
21502                                                                 10987654321098765432109876543210
21503                                                                 xx001110xx1x1xx0111110xxxxxxxxxx
21504                                                                 fabs.  */
21505                                                              return 201;
21506                                                            }
21507                                                          else
21508                                                            {
21509                                                              /* 33222222222211111111110000000000
21510                                                                 10987654321098765432109876543210
21511                                                                 xx101110xx1x1xx0111110xxxxxxxxxx
21512                                                                 fneg.  */
21513                                                              return 250;
21514                                                            }
21515                                                        }
21516                                                    }
21517                                                  else
21518                                                    {
21519                                                      if (((word >> 19) & 0x1) == 0)
21520                                                        {
21521                                                          if (((word >> 23) & 0x1) == 0)
21522                                                            {
21523                                                              if (((word >> 29) & 0x1) == 0)
21524                                                                {
21525                                                                  /* 33222222222211111111110000000000
21526                                                                     10987654321098765432109876543210
21527                                                                     xx0011100x1x0xx1111110xxxxxxxxxx
21528                                                                     frint64z.  */
21529                                                                  return 160;
21530                                                                }
21531                                                              else
21532                                                                {
21533                                                                  /* 33222222222211111111110000000000
21534                                                                     10987654321098765432109876543210
21535                                                                     xx1011100x1x0xx1111110xxxxxxxxxx
21536                                                                     frint64x.  */
21537                                                                  return 161;
21538                                                                }
21539                                                            }
21540                                                          else
21541                                                            {
21542                                                              /* 33222222222211111111110000000000
21543                                                                 10987654321098765432109876543210
21544                                                                 xxx011101x1x0xx1111110xxxxxxxxxx
21545                                                                 fsqrt.  */
21546                                                              return 260;
21547                                                            }
21548                                                        }
21549                                                      else
21550                                                        {
21551                                                          /* 33222222222211111111110000000000
21552                                                             10987654321098765432109876543210
21553                                                             xxx01110xx1x1xx1111110xxxxxxxxxx
21554                                                             fsqrt.  */
21555                                                          return 261;
21556                                                        }
21557                                                    }
21558                                                }
21559                                            }
21560                                        }
21561                                    }
21562                                }
21563                              else
21564                                {
21565                                  if (((word >> 11) & 0x1) == 0)
21566                                    {
21567                                      if (((word >> 12) & 0x1) == 0)
21568                                        {
21569                                          if (((word >> 13) & 0x1) == 0)
21570                                            {
21571                                              if (((word >> 14) & 0x1) == 0)
21572                                                {
21573                                                  if (((word >> 29) & 0x1) == 0)
21574                                                    {
21575                                                      if (((word >> 31) & 0x1) == 0)
21576                                                        {
21577                                                          /* 33222222222211111111110000000000
21578                                                             10987654321098765432109876543210
21579                                                             0x001110xx1xxxxx100001xxxxxxxxxx
21580                                                             add.  */
21581                                                          return 283;
21582                                                        }
21583                                                      else
21584                                                        {
21585                                                          /* 33222222222211111111110000000000
21586                                                             10987654321098765432109876543210
21587                                                             1x001110xx1xxxxx100001xxxxxxxxxx
21588                                                             sha512h2.  */
21589                                                          return 2419;
21590                                                        }
21591                                                    }
21592                                                  else
21593                                                    {
21594                                                      /* 33222222222211111111110000000000
21595                                                         10987654321098765432109876543210
21596                                                         xx101110xx1xxxxx100001xxxxxxxxxx
21597                                                         sub.  */
21598                                                      return 335;
21599                                                    }
21600                                                }
21601                                              else
21602                                                {
21603                                                  if (((word >> 23) & 0x1) == 0)
21604                                                    {
21605                                                      if (((word >> 29) & 0x1) == 0)
21606                                                        {
21607                                                          if (((word >> 31) & 0x1) == 0)
21608                                                            {
21609                                                              /* 33222222222211111111110000000000
21610                                                                 10987654321098765432109876543210
21611                                                                 0x0011100x1xxxxx110001xxxxxxxxxx
21612                                                                 fmaxnm.  */
21613                                                              return 291;
21614                                                            }
21615                                                          else
21616                                                            {
21617                                                              /* 33222222222211111111110000000000
21618                                                                 10987654321098765432109876543210
21619                                                                 1x0011100x1xxxxx110001xxxxxxxxxx
21620                                                                 sm3partw2.  */
21621                                                              return 2432;
21622                                                            }
21623                                                        }
21624                                                      else
21625                                                        {
21626                                                          /* 33222222222211111111110000000000
21627                                                             10987654321098765432109876543210
21628                                                             xx1011100x1xxxxx110001xxxxxxxxxx
21629                                                             fmaxnmp.  */
21630                                                          return 342;
21631                                                        }
21632                                                    }
21633                                                  else
21634                                                    {
21635                                                      if (((word >> 29) & 0x1) == 0)
21636                                                        {
21637                                                          /* 33222222222211111111110000000000
21638                                                             10987654321098765432109876543210
21639                                                             xx0011101x1xxxxx110001xxxxxxxxxx
21640                                                             fminnm.  */
21641                                                          return 307;
21642                                                        }
21643                                                      else
21644                                                        {
21645                                                          /* 33222222222211111111110000000000
21646                                                             10987654321098765432109876543210
21647                                                             xx1011101x1xxxxx110001xxxxxxxxxx
21648                                                             fminnmp.  */
21649                                                          return 358;
21650                                                        }
21651                                                    }
21652                                                }
21653                                            }
21654                                          else
21655                                            {
21656                                              if (((word >> 14) & 0x1) == 0)
21657                                                {
21658                                                  if (((word >> 29) & 0x1) == 0)
21659                                                    {
21660                                                      /* 33222222222211111111110000000000
21661                                                         10987654321098765432109876543210
21662                                                         xx001110xx1xxxxx101001xxxxxxxxxx
21663                                                         smaxp.  */
21664                                                      return 287;
21665                                                    }
21666                                                  else
21667                                                    {
21668                                                      /* 33222222222211111111110000000000
21669                                                         10987654321098765432109876543210
21670                                                         xx101110xx1xxxxx101001xxxxxxxxxx
21671                                                         umaxp.  */
21672                                                      return 339;
21673                                                    }
21674                                                }
21675                                              else
21676                                                {
21677                                                  if (((word >> 23) & 0x1) == 0)
21678                                                    {
21679                                                      if (((word >> 29) & 0x1) == 0)
21680                                                        {
21681                                                          /* 33222222222211111111110000000000
21682                                                             10987654321098765432109876543210
21683                                                             xx0011100x1xxxxx111001xxxxxxxxxx
21684                                                             fcmeq.  */
21685                                                          return 299;
21686                                                        }
21687                                                      else
21688                                                        {
21689                                                          /* 33222222222211111111110000000000
21690                                                             10987654321098765432109876543210
21691                                                             xx1011100x1xxxxx111001xxxxxxxxxx
21692                                                             fcmge.  */
21693                                                          return 348;
21694                                                        }
21695                                                    }
21696                                                  else
21697                                                    {
21698                                                      /* 33222222222211111111110000000000
21699                                                         10987654321098765432109876543210
21700                                                         xxx011101x1xxxxx111001xxxxxxxxxx
21701                                                         fcmgt.  */
21702                                                      return 362;
21703                                                    }
21704                                                }
21705                                            }
21706                                        }
21707                                      else
21708                                        {
21709                                          if (((word >> 13) & 0x1) == 0)
21710                                            {
21711                                              if (((word >> 14) & 0x1) == 0)
21712                                                {
21713                                                  if (((word >> 29) & 0x1) == 0)
21714                                                    {
21715                                                      /* 33222222222211111111110000000000
21716                                                         10987654321098765432109876543210
21717                                                         xx001110xx1xxxxx100101xxxxxxxxxx
21718                                                         mla.  */
21719                                                      return 285;
21720                                                    }
21721                                                  else
21722                                                    {
21723                                                      /* 33222222222211111111110000000000
21724                                                         10987654321098765432109876543210
21725                                                         xx101110xx1xxxxx100101xxxxxxxxxx
21726                                                         mls.  */
21727                                                      return 337;
21728                                                    }
21729                                                }
21730                                              else
21731                                                {
21732                                                  if (((word >> 23) & 0x1) == 0)
21733                                                    {
21734                                                      if (((word >> 29) & 0x1) == 0)
21735                                                        {
21736                                                          /* 33222222222211111111110000000000
21737                                                             10987654321098765432109876543210
21738                                                             xx0011100x1xxxxx110101xxxxxxxxxx
21739                                                             fadd.  */
21740                                                          return 295;
21741                                                        }
21742                                                      else
21743                                                        {
21744                                                          /* 33222222222211111111110000000000
21745                                                             10987654321098765432109876543210
21746                                                             xx1011100x1xxxxx110101xxxxxxxxxx
21747                                                             faddp.  */
21748                                                          return 344;
21749                                                        }
21750                                                    }
21751                                                  else
21752                                                    {
21753                                                      if (((word >> 29) & 0x1) == 0)
21754                                                        {
21755                                                          /* 33222222222211111111110000000000
21756                                                             10987654321098765432109876543210
21757                                                             xx0011101x1xxxxx110101xxxxxxxxxx
21758                                                             fsub.  */
21759                                                          return 311;
21760                                                        }
21761                                                      else
21762                                                        {
21763                                                          /* 33222222222211111111110000000000
21764                                                             10987654321098765432109876543210
21765                                                             xx1011101x1xxxxx110101xxxxxxxxxx
21766                                                             fabd.  */
21767                                                          return 360;
21768                                                        }
21769                                                    }
21770                                                }
21771                                            }
21772                                          else
21773                                            {
21774                                              if (((word >> 14) & 0x1) == 0)
21775                                                {
21776                                                  if (((word >> 29) & 0x1) == 0)
21777                                                    {
21778                                                      /* 33222222222211111111110000000000
21779                                                         10987654321098765432109876543210
21780                                                         xx001110xx1xxxxx101101xxxxxxxxxx
21781                                                         sqdmulh.  */
21782                                                      return 289;
21783                                                    }
21784                                                  else
21785                                                    {
21786                                                      /* 33222222222211111111110000000000
21787                                                         10987654321098765432109876543210
21788                                                         xx101110xx1xxxxx101101xxxxxxxxxx
21789                                                         sqrdmulh.  */
21790                                                      return 341;
21791                                                    }
21792                                                }
21793                                              else
21794                                                {
21795                                                  if (((word >> 23) & 0x1) == 0)
21796                                                    {
21797                                                      if (((word >> 29) & 0x1) == 0)
21798                                                        {
21799                                                          /* 33222222222211111111110000000000
21800                                                             10987654321098765432109876543210
21801                                                             xx0011100x1xxxxx111101xxxxxxxxxx
21802                                                             fmax.  */
21803                                                          return 301;
21804                                                        }
21805                                                      else
21806                                                        {
21807                                                          /* 33222222222211111111110000000000
21808                                                             10987654321098765432109876543210
21809                                                             xx1011100x1xxxxx111101xxxxxxxxxx
21810                                                             fmaxp.  */
21811                                                          return 352;
21812                                                        }
21813                                                    }
21814                                                  else
21815                                                    {
21816                                                      if (((word >> 29) & 0x1) == 0)
21817                                                        {
21818                                                          /* 33222222222211111111110000000000
21819                                                             10987654321098765432109876543210
21820                                                             xx0011101x1xxxxx111101xxxxxxxxxx
21821                                                             fmin.  */
21822                                                          return 313;
21823                                                        }
21824                                                      else
21825                                                        {
21826                                                          /* 33222222222211111111110000000000
21827                                                             10987654321098765432109876543210
21828                                                             xx1011101x1xxxxx111101xxxxxxxxxx
21829                                                             fminp.  */
21830                                                          return 366;
21831                                                        }
21832                                                    }
21833                                                }
21834                                            }
21835                                        }
21836                                    }
21837                                  else
21838                                    {
21839                                      if (((word >> 12) & 0x1) == 0)
21840                                        {
21841                                          if (((word >> 13) & 0x1) == 0)
21842                                            {
21843                                              if (((word >> 14) & 0x1) == 0)
21844                                                {
21845                                                  if (((word >> 29) & 0x1) == 0)
21846                                                    {
21847                                                      if (((word >> 31) & 0x1) == 0)
21848                                                        {
21849                                                          /* 33222222222211111111110000000000
21850                                                             10987654321098765432109876543210
21851                                                             0x001110xx1xxxxx100011xxxxxxxxxx
21852                                                             cmtst.  */
21853                                                          return 284;
21854                                                        }
21855                                                      else
21856                                                        {
21857                                                          /* 33222222222211111111110000000000
21858                                                             10987654321098765432109876543210
21859                                                             1x001110xx1xxxxx100011xxxxxxxxxx
21860                                                             rax1.  */
21861                                                          return 2423;
21862                                                        }
21863                                                    }
21864                                                  else
21865                                                    {
21866                                                      /* 33222222222211111111110000000000
21867                                                         10987654321098765432109876543210
21868                                                         xx101110xx1xxxxx100011xxxxxxxxxx
21869                                                         cmeq.  */
21870                                                      return 336;
21871                                                    }
21872                                                }
21873                                              else
21874                                                {
21875                                                  if (((word >> 23) & 0x1) == 0)
21876                                                    {
21877                                                      if (((word >> 29) & 0x1) == 0)
21878                                                        {
21879                                                          /* 33222222222211111111110000000000
21880                                                             10987654321098765432109876543210
21881                                                             xx0011100x1xxxxx110011xxxxxxxxxx
21882                                                             fmla.  */
21883                                                          return 293;
21884                                                        }
21885                                                      else
21886                                                        {
21887                                                          if (((word >> 30) & 0x1) == 0)
21888                                                            {
21889                                                              /* 33222222222211111111110000000000
21890                                                                 10987654321098765432109876543210
21891                                                                 x01011100x1xxxxx110011xxxxxxxxxx
21892                                                                 fmlal2.  */
21893                                                              return 2437;
21894                                                            }
21895                                                          else
21896                                                            {
21897                                                              /* 33222222222211111111110000000000
21898                                                                 10987654321098765432109876543210
21899                                                                 x11011100x1xxxxx110011xxxxxxxxxx
21900                                                                 fmlal2.  */
21901                                                              return 2441;
21902                                                            }
21903                                                        }
21904                                                    }
21905                                                  else
21906                                                    {
21907                                                      if (((word >> 29) & 0x1) == 0)
21908                                                        {
21909                                                          /* 33222222222211111111110000000000
21910                                                             10987654321098765432109876543210
21911                                                             xx0011101x1xxxxx110011xxxxxxxxxx
21912                                                             fmls.  */
21913                                                          return 309;
21914                                                        }
21915                                                      else
21916                                                        {
21917                                                          if (((word >> 30) & 0x1) == 0)
21918                                                            {
21919                                                              /* 33222222222211111111110000000000
21920                                                                 10987654321098765432109876543210
21921                                                                 x01011101x1xxxxx110011xxxxxxxxxx
21922                                                                 fmlsl2.  */
21923                                                              return 2438;
21924                                                            }
21925                                                          else
21926                                                            {
21927                                                              /* 33222222222211111111110000000000
21928                                                                 10987654321098765432109876543210
21929                                                                 x11011101x1xxxxx110011xxxxxxxxxx
21930                                                                 fmlsl2.  */
21931                                                              return 2442;
21932                                                            }
21933                                                        }
21934                                                    }
21935                                                }
21936                                            }
21937                                          else
21938                                            {
21939                                              if (((word >> 14) & 0x1) == 0)
21940                                                {
21941                                                  if (((word >> 29) & 0x1) == 0)
21942                                                    {
21943                                                      /* 33222222222211111111110000000000
21944                                                         10987654321098765432109876543210
21945                                                         xx001110xx1xxxxx101011xxxxxxxxxx
21946                                                         sminp.  */
21947                                                      return 288;
21948                                                    }
21949                                                  else
21950                                                    {
21951                                                      /* 33222222222211111111110000000000
21952                                                         10987654321098765432109876543210
21953                                                         xx101110xx1xxxxx101011xxxxxxxxxx
21954                                                         uminp.  */
21955                                                      return 340;
21956                                                    }
21957                                                }
21958                                              else
21959                                                {
21960                                                  if (((word >> 23) & 0x1) == 0)
21961                                                    {
21962                                                      if (((word >> 29) & 0x1) == 0)
21963                                                        {
21964                                                          if (((word >> 30) & 0x1) == 0)
21965                                                            {
21966                                                              /* 33222222222211111111110000000000
21967                                                                 10987654321098765432109876543210
21968                                                                 x00011100x1xxxxx111011xxxxxxxxxx
21969                                                                 fmlal.  */
21970                                                              return 2435;
21971                                                            }
21972                                                          else
21973                                                            {
21974                                                              /* 33222222222211111111110000000000
21975                                                                 10987654321098765432109876543210
21976                                                                 x10011100x1xxxxx111011xxxxxxxxxx
21977                                                                 fmlal.  */
21978                                                              return 2439;
21979                                                            }
21980                                                        }
21981                                                      else
21982                                                        {
21983                                                          /* 33222222222211111111110000000000
21984                                                             10987654321098765432109876543210
21985                                                             xx1011100x1xxxxx111011xxxxxxxxxx
21986                                                             facge.  */
21987                                                          return 350;
21988                                                        }
21989                                                    }
21990                                                  else
21991                                                    {
21992                                                      if (((word >> 29) & 0x1) == 0)
21993                                                        {
21994                                                          if (((word >> 30) & 0x1) == 0)
21995                                                            {
21996                                                              /* 33222222222211111111110000000000
21997                                                                 10987654321098765432109876543210
21998                                                                 x00011101x1xxxxx111011xxxxxxxxxx
21999                                                                 fmlsl.  */
22000                                                              return 2436;
22001                                                            }
22002                                                          else
22003                                                            {
22004                                                              /* 33222222222211111111110000000000
22005                                                                 10987654321098765432109876543210
22006                                                                 x10011101x1xxxxx111011xxxxxxxxxx
22007                                                                 fmlsl.  */
22008                                                              return 2440;
22009                                                            }
22010                                                        }
22011                                                      else
22012                                                        {
22013                                                          /* 33222222222211111111110000000000
22014                                                             10987654321098765432109876543210
22015                                                             xx1011101x1xxxxx111011xxxxxxxxxx
22016                                                             facgt.  */
22017                                                          return 364;
22018                                                        }
22019                                                    }
22020                                                }
22021                                            }
22022                                        }
22023                                      else
22024                                        {
22025                                          if (((word >> 13) & 0x1) == 0)
22026                                            {
22027                                              if (((word >> 14) & 0x1) == 0)
22028                                                {
22029                                                  if (((word >> 29) & 0x1) == 0)
22030                                                    {
22031                                                      /* 33222222222211111111110000000000
22032                                                         10987654321098765432109876543210
22033                                                         xx001110xx1xxxxx100111xxxxxxxxxx
22034                                                         mul.  */
22035                                                      return 286;
22036                                                    }
22037                                                  else
22038                                                    {
22039                                                      /* 33222222222211111111110000000000
22040                                                         10987654321098765432109876543210
22041                                                         xx101110xx1xxxxx100111xxxxxxxxxx
22042                                                         pmul.  */
22043                                                      return 338;
22044                                                    }
22045                                                }
22046                                              else
22047                                                {
22048                                                  if (((word >> 29) & 0x1) == 0)
22049                                                    {
22050                                                      /* 33222222222211111111110000000000
22051                                                         10987654321098765432109876543210
22052                                                         xx001110xx1xxxxx110111xxxxxxxxxx
22053                                                         fmulx.  */
22054                                                      return 297;
22055                                                    }
22056                                                  else
22057                                                    {
22058                                                      /* 33222222222211111111110000000000
22059                                                         10987654321098765432109876543210
22060                                                         xx101110xx1xxxxx110111xxxxxxxxxx
22061                                                         fmul.  */
22062                                                      return 346;
22063                                                    }
22064                                                }
22065                                            }
22066                                          else
22067                                            {
22068                                              if (((word >> 14) & 0x1) == 0)
22069                                                {
22070                                                  /* 33222222222211111111110000000000
22071                                                     10987654321098765432109876543210
22072                                                     xxx01110xx1xxxxx101111xxxxxxxxxx
22073                                                     addp.  */
22074                                                  return 290;
22075                                                }
22076                                              else
22077                                                {
22078                                                  if (((word >> 23) & 0x1) == 0)
22079                                                    {
22080                                                      if (((word >> 29) & 0x1) == 0)
22081                                                        {
22082                                                          /* 33222222222211111111110000000000
22083                                                             10987654321098765432109876543210
22084                                                             xx0011100x1xxxxx111111xxxxxxxxxx
22085                                                             frecps.  */
22086                                                          return 303;
22087                                                        }
22088                                                      else
22089                                                        {
22090                                                          /* 33222222222211111111110000000000
22091                                                             10987654321098765432109876543210
22092                                                             xx1011100x1xxxxx111111xxxxxxxxxx
22093                                                             fdiv.  */
22094                                                          return 354;
22095                                                        }
22096                                                    }
22097                                                  else
22098                                                    {
22099                                                      /* 33222222222211111111110000000000
22100                                                         10987654321098765432109876543210
22101                                                         xxx011101x1xxxxx111111xxxxxxxxxx
22102                                                         frsqrts.  */
22103                                                      return 315;
22104                                                    }
22105                                                }
22106                                            }
22107                                        }
22108                                    }
22109                                }
22110                            }
22111                        }
22112                      else
22113                        {
22114                          if (((word >> 10) & 0x1) == 0)
22115                            {
22116                              if (((word >> 11) & 0x1) == 0)
22117                                {
22118                                  if (((word >> 12) & 0x1) == 0)
22119                                    {
22120                                      if (((word >> 13) & 0x1) == 0)
22121                                        {
22122                                          if (((word >> 14) & 0x1) == 0)
22123                                            {
22124                                              if (((word >> 16) & 0x1) == 0)
22125                                                {
22126                                                  if (((word >> 17) & 0x1) == 0)
22127                                                    {
22128                                                      if (((word >> 18) & 0x1) == 0)
22129                                                        {
22130                                                          if (((word >> 19) & 0x1) == 0)
22131                                                            {
22132                                                              if (((word >> 20) & 0x1) == 0)
22133                                                                {
22134                                                                  /* 33222222222211111111110000000000
22135                                                                     10987654321098765432109876543210
22136                                                                     xxx11110xx100000x00000xxxxxxxxxx
22137                                                                     fcvtns.  */
22138                                                                  return 768;
22139                                                                }
22140                                                              else
22141                                                                {
22142                                                                  /* 33222222222211111111110000000000
22143                                                                     10987654321098765432109876543210
22144                                                                     xxx11110xx110000x00000xxxxxxxxxx
22145                                                                     fcvtms.  */
22146                                                                  return 788;
22147                                                                }
22148                                                            }
22149                                                          else
22150                                                            {
22151                                                              if (((word >> 20) & 0x1) == 0)
22152                                                                {
22153                                                                  /* 33222222222211111111110000000000
22154                                                                     10987654321098765432109876543210
22155                                                                     xxx11110xx101000x00000xxxxxxxxxx
22156                                                                     fcvtps.  */
22157                                                                  return 784;
22158                                                                }
22159                                                              else
22160                                                                {
22161                                                                  /* 33222222222211111111110000000000
22162                                                                     10987654321098765432109876543210
22163                                                                     xxx11110xx111000x00000xxxxxxxxxx
22164                                                                     fcvtzs.  */
22165                                                                  return 792;
22166                                                                }
22167                                                            }
22168                                                        }
22169                                                      else
22170                                                        {
22171                                                          /* 33222222222211111111110000000000
22172                                                             10987654321098765432109876543210
22173                                                             xxx11110xx1xx100x00000xxxxxxxxxx
22174                                                             fcvtas.  */
22175                                                          return 776;
22176                                                        }
22177                                                    }
22178                                                  else
22179                                                    {
22180                                                      if (((word >> 18) & 0x1) == 0)
22181                                                        {
22182                                                          /* 33222222222211111111110000000000
22183                                                             10987654321098765432109876543210
22184                                                             xxx11110xx1xx010x00000xxxxxxxxxx
22185                                                             scvtf.  */
22186                                                          return 772;
22187                                                        }
22188                                                      else
22189                                                        {
22190                                                          if (((word >> 19) & 0x1) == 0)
22191                                                            {
22192                                                              /* 33222222222211111111110000000000
22193                                                                 10987654321098765432109876543210
22194                                                                 xxx11110xx1x0110x00000xxxxxxxxxx
22195                                                                 fmov.  */
22196                                                              return 780;
22197                                                            }
22198                                                          else
22199                                                            {
22200                                                              if (((word >> 20) & 0x1) == 0)
22201                                                                {
22202                                                                  /* 33222222222211111111110000000000
22203                                                                     10987654321098765432109876543210
22204                                                                     xxx11110xx101110x00000xxxxxxxxxx
22205                                                                     fmov.  */
22206                                                                  return 796;
22207                                                                }
22208                                                              else
22209                                                                {
22210                                                                  /* 33222222222211111111110000000000
22211                                                                     10987654321098765432109876543210
22212                                                                     xxx11110xx111110x00000xxxxxxxxxx
22213                                                                     fjcvtzs.  */
22214                                                                  return 798;
22215                                                                }
22216                                                            }
22217                                                        }
22218                                                    }
22219                                                }
22220                                              else
22221                                                {
22222                                                  if (((word >> 17) & 0x1) == 0)
22223                                                    {
22224                                                      if (((word >> 18) & 0x1) == 0)
22225                                                        {
22226                                                          if (((word >> 19) & 0x1) == 0)
22227                                                            {
22228                                                              if (((word >> 20) & 0x1) == 0)
22229                                                                {
22230                                                                  /* 33222222222211111111110000000000
22231                                                                     10987654321098765432109876543210
22232                                                                     xxx11110xx100001x00000xxxxxxxxxx
22233                                                                     fcvtnu.  */
22234                                                                  return 770;
22235                                                                }
22236                                                              else
22237                                                                {
22238                                                                  /* 33222222222211111111110000000000
22239                                                                     10987654321098765432109876543210
22240                                                                     xxx11110xx110001x00000xxxxxxxxxx
22241                                                                     fcvtmu.  */
22242                                                                  return 790;
22243                                                                }
22244                                                            }
22245                                                          else
22246                                                            {
22247                                                              if (((word >> 20) & 0x1) == 0)
22248                                                                {
22249                                                                  /* 33222222222211111111110000000000
22250                                                                     10987654321098765432109876543210
22251                                                                     xxx11110xx101001x00000xxxxxxxxxx
22252                                                                     fcvtpu.  */
22253                                                                  return 786;
22254                                                                }
22255                                                              else
22256                                                                {
22257                                                                  /* 33222222222211111111110000000000
22258                                                                     10987654321098765432109876543210
22259                                                                     xxx11110xx111001x00000xxxxxxxxxx
22260                                                                     fcvtzu.  */
22261                                                                  return 794;
22262                                                                }
22263                                                            }
22264                                                        }
22265                                                      else
22266                                                        {
22267                                                          /* 33222222222211111111110000000000
22268                                                             10987654321098765432109876543210
22269                                                             xxx11110xx1xx101x00000xxxxxxxxxx
22270                                                             fcvtau.  */
22271                                                          return 778;
22272                                                        }
22273                                                    }
22274                                                  else
22275                                                    {
22276                                                      if (((word >> 18) & 0x1) == 0)
22277                                                        {
22278                                                          /* 33222222222211111111110000000000
22279                                                             10987654321098765432109876543210
22280                                                             xxx11110xx1xx011x00000xxxxxxxxxx
22281                                                             ucvtf.  */
22282                                                          return 774;
22283                                                        }
22284                                                      else
22285                                                        {
22286                                                          if (((word >> 19) & 0x1) == 0)
22287                                                            {
22288                                                              /* 33222222222211111111110000000000
22289                                                                 10987654321098765432109876543210
22290                                                                 xxx11110xx1x0111x00000xxxxxxxxxx
22291                                                                 fmov.  */
22292                                                              return 782;
22293                                                            }
22294                                                          else
22295                                                            {
22296                                                              /* 33222222222211111111110000000000
22297                                                                 10987654321098765432109876543210
22298                                                                 xxx11110xx1x1111x00000xxxxxxxxxx
22299                                                                 fmov.  */
22300                                                              return 797;
22301                                                            }
22302                                                        }
22303                                                    }
22304                                                }
22305                                            }
22306                                          else
22307                                            {
22308                                              if (((word >> 17) & 0x1) == 0)
22309                                                {
22310                                                  if (((word >> 15) & 0x1) == 0)
22311                                                    {
22312                                                      if (((word >> 16) & 0x1) == 0)
22313                                                        {
22314                                                          if (((word >> 18) & 0x1) == 0)
22315                                                            {
22316                                                              if (((word >> 19) & 0x1) == 0)
22317                                                                {
22318                                                                  /* 33222222222211111111110000000000
22319                                                                     10987654321098765432109876543210
22320                                                                     xxx11110xx1x0000010000xxxxxxxxxx
22321                                                                     fmov.  */
22322                                                                  return 817;
22323                                                                }
22324                                                              else
22325                                                                {
22326                                                                  /* 33222222222211111111110000000000
22327                                                                     10987654321098765432109876543210
22328                                                                     xxx11110xx1x1000010000xxxxxxxxxx
22329                                                                     frint32z.  */
22330                                                                  return 813;
22331                                                                }
22332                                                            }
22333                                                          else
22334                                                            {
22335                                                              /* 33222222222211111111110000000000
22336                                                                 10987654321098765432109876543210
22337                                                                 xxx11110xx1xx100010000xxxxxxxxxx
22338                                                                 frintn.  */
22339                                                              return 826;
22340                                                            }
22341                                                        }
22342                                                      else
22343                                                        {
22344                                                          if (((word >> 18) & 0x1) == 0)
22345                                                            {
22346                                                              if (((word >> 19) & 0x1) == 0)
22347                                                                {
22348                                                                  /* 33222222222211111111110000000000
22349                                                                     10987654321098765432109876543210
22350                                                                     xxx11110xx1x0001010000xxxxxxxxxx
22351                                                                     fneg.  */
22352                                                                  return 821;
22353                                                                }
22354                                                              else
22355                                                                {
22356                                                                  /* 33222222222211111111110000000000
22357                                                                     10987654321098765432109876543210
22358                                                                     xxx11110xx1x1001010000xxxxxxxxxx
22359                                                                     frint64z.  */
22360                                                                  return 815;
22361                                                                }
22362                                                            }
22363                                                          else
22364                                                            {
22365                                                              /* 33222222222211111111110000000000
22366                                                                 10987654321098765432109876543210
22367                                                                 xxx11110xx1xx101010000xxxxxxxxxx
22368                                                                 frintm.  */
22369                                                              return 830;
22370                                                            }
22371                                                        }
22372                                                    }
22373                                                  else
22374                                                    {
22375                                                      if (((word >> 16) & 0x1) == 0)
22376                                                        {
22377                                                          if (((word >> 18) & 0x1) == 0)
22378                                                            {
22379                                                              if (((word >> 19) & 0x1) == 0)
22380                                                                {
22381                                                                  /* 33222222222211111111110000000000
22382                                                                     10987654321098765432109876543210
22383                                                                     xxx11110xx1x0000110000xxxxxxxxxx
22384                                                                     fabs.  */
22385                                                                  return 819;
22386                                                                }
22387                                                              else
22388                                                                {
22389                                                                  /* 33222222222211111111110000000000
22390                                                                     10987654321098765432109876543210
22391                                                                     xxx11110xx1x1000110000xxxxxxxxxx
22392                                                                     frint32x.  */
22393                                                                  return 814;
22394                                                                }
22395                                                            }
22396                                                          else
22397                                                            {
22398                                                              /* 33222222222211111111110000000000
22399                                                                 10987654321098765432109876543210
22400                                                                 xxx11110xx1xx100110000xxxxxxxxxx
22401                                                                 frintp.  */
22402                                                              return 828;
22403                                                            }
22404                                                        }
22405                                                      else
22406                                                        {
22407                                                          if (((word >> 18) & 0x1) == 0)
22408                                                            {
22409                                                              if (((word >> 19) & 0x1) == 0)
22410                                                                {
22411                                                                  /* 33222222222211111111110000000000
22412                                                                     10987654321098765432109876543210
22413                                                                     xxx11110xx1x0001110000xxxxxxxxxx
22414                                                                     fsqrt.  */
22415                                                                  return 823;
22416                                                                }
22417                                                              else
22418                                                                {
22419                                                                  /* 33222222222211111111110000000000
22420                                                                     10987654321098765432109876543210
22421                                                                     xxx11110xx1x1001110000xxxxxxxxxx
22422                                                                     frint64x.  */
22423                                                                  return 816;
22424                                                                }
22425                                                            }
22426                                                          else
22427                                                            {
22428                                                              /* 33222222222211111111110000000000
22429                                                                 10987654321098765432109876543210
22430                                                                 xxx11110xx1xx101110000xxxxxxxxxx
22431                                                                 frintz.  */
22432                                                              return 832;
22433                                                            }
22434                                                        }
22435                                                    }
22436                                                }
22437                                              else
22438                                                {
22439                                                  if (((word >> 18) & 0x1) == 0)
22440                                                    {
22441                                                      /* 33222222222211111111110000000000
22442                                                         10987654321098765432109876543210
22443                                                         xxx11110xx1xx01xx10000xxxxxxxxxx
22444                                                         fcvt.  */
22445                                                      return 825;
22446                                                    }
22447                                                  else
22448                                                    {
22449                                                      if (((word >> 15) & 0x1) == 0)
22450                                                        {
22451                                                          if (((word >> 16) & 0x1) == 0)
22452                                                            {
22453                                                              /* 33222222222211111111110000000000
22454                                                                 10987654321098765432109876543210
22455                                                                 xxx11110xx1xx110010000xxxxxxxxxx
22456                                                                 frinta.  */
22457                                                              return 834;
22458                                                            }
22459                                                          else
22460                                                            {
22461                                                              /* 33222222222211111111110000000000
22462                                                                 10987654321098765432109876543210
22463                                                                 xxx11110xx1xx111010000xxxxxxxxxx
22464                                                                 frintx.  */
22465                                                              return 836;
22466                                                            }
22467                                                        }
22468                                                      else
22469                                                        {
22470                                                          /* 33222222222211111111110000000000
22471                                                             10987654321098765432109876543210
22472                                                             xxx11110xx1xx11x110000xxxxxxxxxx
22473                                                             frinti.  */
22474                                                          return 838;
22475                                                        }
22476                                                    }
22477                                                }
22478                                            }
22479                                        }
22480                                      else
22481                                        {
22482                                          if (((word >> 3) & 0x1) == 0)
22483                                            {
22484                                              if (((word >> 4) & 0x1) == 0)
22485                                                {
22486                                                  /* 33222222222211111111110000000000
22487                                                     10987654321098765432109876543210
22488                                                     xxx11110xx1xxxxxxx1000xxxxx00xxx
22489                                                     fcmp.  */
22490                                                  return 803;
22491                                                }
22492                                              else
22493                                                {
22494                                                  /* 33222222222211111111110000000000
22495                                                     10987654321098765432109876543210
22496                                                     xxx11110xx1xxxxxxx1000xxxxx10xxx
22497                                                     fcmpe.  */
22498                                                  return 805;
22499                                                }
22500                                            }
22501                                          else
22502                                            {
22503                                              if (((word >> 4) & 0x1) == 0)
22504                                                {
22505                                                  /* 33222222222211111111110000000000
22506                                                     10987654321098765432109876543210
22507                                                     xxx11110xx1xxxxxxx1000xxxxx01xxx
22508                                                     fcmp.  */
22509                                                  return 807;
22510                                                }
22511                                              else
22512                                                {
22513                                                  /* 33222222222211111111110000000000
22514                                                     10987654321098765432109876543210
22515                                                     xxx11110xx1xxxxxxx1000xxxxx11xxx
22516                                                     fcmpe.  */
22517                                                  return 809;
22518                                                }
22519                                            }
22520                                        }
22521                                    }
22522                                  else
22523                                    {
22524                                      if (((word >> 30) & 0x1) == 0)
22525                                        {
22526                                          /* 33222222222211111111110000000000
22527                                             10987654321098765432109876543210
22528                                             x0x11110xx1xxxxxxxx100xxxxxxxxxx
22529                                             fmov.  */
22530                                          return 866;
22531                                        }
22532                                      else
22533                                        {
22534                                          if (((word >> 13) & 0x1) == 0)
22535                                            {
22536                                              if (((word >> 14) & 0x1) == 0)
22537                                                {
22538                                                  /* 33222222222211111111110000000000
22539                                                     10987654321098765432109876543210
22540                                                     x1x11110xx1xxxxxx00100xxxxxxxxxx
22541                                                     sqdmlal.  */
22542                                                  return 422;
22543                                                }
22544                                              else
22545                                                {
22546                                                  /* 33222222222211111111110000000000
22547                                                     10987654321098765432109876543210
22548                                                     x1x11110xx1xxxxxx10100xxxxxxxxxx
22549                                                     sqdmull.  */
22550                                                  return 424;
22551                                                }
22552                                            }
22553                                          else
22554                                            {
22555                                              /* 33222222222211111111110000000000
22556                                                 10987654321098765432109876543210
22557                                                 x1x11110xx1xxxxxxx1100xxxxxxxxxx
22558                                                 sqdmlsl.  */
22559                                              return 423;
22560                                            }
22561                                        }
22562                                    }
22563                                }
22564                              else
22565                                {
22566                                  if (((word >> 12) & 0x1) == 0)
22567                                    {
22568                                      if (((word >> 13) & 0x1) == 0)
22569                                        {
22570                                          if (((word >> 14) & 0x1) == 0)
22571                                            {
22572                                              if (((word >> 15) & 0x1) == 0)
22573                                                {
22574                                                  if (((word >> 30) & 0x1) == 0)
22575                                                    {
22576                                                      /* 33222222222211111111110000000000
22577                                                         10987654321098765432109876543210
22578                                                         x0x11110xx1xxxxx000010xxxxxxxxxx
22579                                                         fmul.  */
22580                                                      return 840;
22581                                                    }
22582                                                  else
22583                                                    {
22584                                                      /* 33222222222211111111110000000000
22585                                                         10987654321098765432109876543210
22586                                                         x1x11110xx1xxxxx000010xxxxxxxxxx
22587                                                         sha1h.  */
22588                                                      return 675;
22589                                                    }
22590                                                }
22591                                              else
22592                                                {
22593                                                  if (((word >> 29) & 0x1) == 0)
22594                                                    {
22595                                                      if (((word >> 30) & 0x1) == 0)
22596                                                        {
22597                                                          /* 33222222222211111111110000000000
22598                                                             10987654321098765432109876543210
22599                                                             x0011110xx1xxxxx100010xxxxxxxxxx
22600                                                             fnmul.  */
22601                                                          return 856;
22602                                                        }
22603                                                      else
22604                                                        {
22605                                                          /* 33222222222211111111110000000000
22606                                                             10987654321098765432109876543210
22607                                                             x1011110xx1xxxxx100010xxxxxxxxxx
22608                                                             cmgt.  */
22609                                                          return 482;
22610                                                        }
22611                                                    }
22612                                                  else
22613                                                    {
22614                                                      /* 33222222222211111111110000000000
22615                                                         10987654321098765432109876543210
22616                                                         xx111110xx1xxxxx100010xxxxxxxxxx
22617                                                         cmge.  */
22618                                                      return 511;
22619                                                    }
22620                                                }
22621                                            }
22622                                          else
22623                                            {
22624                                              if (((word >> 15) & 0x1) == 0)
22625                                                {
22626                                                  if (((word >> 29) & 0x1) == 0)
22627                                                    {
22628                                                      if (((word >> 30) & 0x1) == 0)
22629                                                        {
22630                                                          /* 33222222222211111111110000000000
22631                                                             10987654321098765432109876543210
22632                                                             x0011110xx1xxxxx010010xxxxxxxxxx
22633                                                             fmax.  */
22634                                                          return 848;
22635                                                        }
22636                                                      else
22637                                                        {
22638                                                          /* 33222222222211111111110000000000
22639                                                             10987654321098765432109876543210
22640                                                             x1011110xx1xxxxx010010xxxxxxxxxx
22641                                                             sqxtn.  */
22642                                                          return 486;
22643                                                        }
22644                                                    }
22645                                                  else
22646                                                    {
22647                                                      /* 33222222222211111111110000000000
22648                                                         10987654321098765432109876543210
22649                                                         xx111110xx1xxxxx010010xxxxxxxxxx
22650                                                         uqxtn.  */
22651                                                      return 515;
22652                                                    }
22653                                                }
22654                                              else
22655                                                {
22656                                                  if (((word >> 16) & 0x1) == 0)
22657                                                    {
22658                                                      if (((word >> 19) & 0x1) == 0)
22659                                                        {
22660                                                          if (((word >> 20) & 0x1) == 0)
22661                                                            {
22662                                                              if (((word >> 29) & 0x1) == 0)
22663                                                                {
22664                                                                  /* 33222222222211111111110000000000
22665                                                                     10987654321098765432109876543210
22666                                                                     xx011110xx100xx0110010xxxxxxxxxx
22667                                                                     fcmgt.  */
22668                                                                  return 495;
22669                                                                }
22670                                                              else
22671                                                                {
22672                                                                  /* 33222222222211111111110000000000
22673                                                                     10987654321098765432109876543210
22674                                                                     xx111110xx100xx0110010xxxxxxxxxx
22675                                                                     fcmge.  */
22676                                                                  return 525;
22677                                                                }
22678                                                            }
22679                                                          else
22680                                                            {
22681                                                              if (((word >> 23) & 0x1) == 0)
22682                                                                {
22683                                                                  if (((word >> 29) & 0x1) == 0)
22684                                                                    {
22685                                                                      /* 33222222222211111111110000000000
22686                                                                         10987654321098765432109876543210
22687                                                                         xx0111100x110xx0110010xxxxxxxxxx
22688                                                                         fmaxnmp.  */
22689                                                                      return 539;
22690                                                                    }
22691                                                                  else
22692                                                                    {
22693                                                                      /* 33222222222211111111110000000000
22694                                                                         10987654321098765432109876543210
22695                                                                         xx1111100x110xx0110010xxxxxxxxxx
22696                                                                         fmaxnmp.  */
22697                                                                      return 538;
22698                                                                    }
22699                                                                }
22700                                                              else
22701                                                                {
22702                                                                  if (((word >> 29) & 0x1) == 0)
22703                                                                    {
22704                                                                      /* 33222222222211111111110000000000
22705                                                                         10987654321098765432109876543210
22706                                                                         xx0111101x110xx0110010xxxxxxxxxx
22707                                                                         fminnmp.  */
22708                                                                      return 545;
22709                                                                    }
22710                                                                  else
22711                                                                    {
22712                                                                      /* 33222222222211111111110000000000
22713                                                                         10987654321098765432109876543210
22714                                                                         xx1111101x110xx0110010xxxxxxxxxx
22715                                                                         fminnmp.  */
22716                                                                      return 544;
22717                                                                    }
22718                                                                }
22719                                                            }
22720                                                        }
22721                                                      else
22722                                                        {
22723                                                          if (((word >> 29) & 0x1) == 0)
22724                                                            {
22725                                                              /* 33222222222211111111110000000000
22726                                                                 10987654321098765432109876543210
22727                                                                 xx011110xx1x1xx0110010xxxxxxxxxx
22728                                                                 fcmgt.  */
22729                                                              return 496;
22730                                                            }
22731                                                          else
22732                                                            {
22733                                                              /* 33222222222211111111110000000000
22734                                                                 10987654321098765432109876543210
22735                                                                 xx111110xx1x1xx0110010xxxxxxxxxx
22736                                                                 fcmge.  */
22737                                                              return 526;
22738                                                            }
22739                                                        }
22740                                                    }
22741                                                  else
22742                                                    {
22743                                                      if (((word >> 19) & 0x1) == 0)
22744                                                        {
22745                                                          if (((word >> 29) & 0x1) == 0)
22746                                                            {
22747                                                              /* 33222222222211111111110000000000
22748                                                                 10987654321098765432109876543210
22749                                                                 xx011110xx1x0xx1110010xxxxxxxxxx
22750                                                                 fcvtas.  */
22751                                                              return 491;
22752                                                            }
22753                                                          else
22754                                                            {
22755                                                              /* 33222222222211111111110000000000
22756                                                                 10987654321098765432109876543210
22757                                                                 xx111110xx1x0xx1110010xxxxxxxxxx
22758                                                                 fcvtau.  */
22759                                                              return 521;
22760                                                            }
22761                                                        }
22762                                                      else
22763                                                        {
22764                                                          if (((word >> 29) & 0x1) == 0)
22765                                                            {
22766                                                              /* 33222222222211111111110000000000
22767                                                                 10987654321098765432109876543210
22768                                                                 xx011110xx1x1xx1110010xxxxxxxxxx
22769                                                                 fcvtas.  */
22770                                                              return 492;
22771                                                            }
22772                                                          else
22773                                                            {
22774                                                              /* 33222222222211111111110000000000
22775                                                                 10987654321098765432109876543210
22776                                                                 xx111110xx1x1xx1110010xxxxxxxxxx
22777                                                                 fcvtau.  */
22778                                                              return 522;
22779                                                            }
22780                                                        }
22781                                                    }
22782                                                }
22783                                            }
22784                                        }
22785                                      else
22786                                        {
22787                                          if (((word >> 14) & 0x1) == 0)
22788                                            {
22789                                              if (((word >> 15) & 0x1) == 0)
22790                                                {
22791                                                  if (((word >> 29) & 0x1) == 0)
22792                                                    {
22793                                                      if (((word >> 30) & 0x1) == 0)
22794                                                        {
22795                                                          /* 33222222222211111111110000000000
22796                                                             10987654321098765432109876543210
22797                                                             x0011110xx1xxxxx001010xxxxxxxxxx
22798                                                             fadd.  */
22799                                                          return 844;
22800                                                        }
22801                                                      else
22802                                                        {
22803                                                          /* 33222222222211111111110000000000
22804                                                             10987654321098765432109876543210
22805                                                             x1011110xx1xxxxx001010xxxxxxxxxx
22806                                                             sha256su0.  */
22807                                                          return 677;
22808                                                        }
22809                                                    }
22810                                                  else
22811                                                    {
22812                                                      /* 33222222222211111111110000000000
22813                                                         10987654321098765432109876543210
22814                                                         xx111110xx1xxxxx001010xxxxxxxxxx
22815                                                         sqxtun.  */
22816                                                      return 514;
22817                                                    }
22818                                                }
22819                                              else
22820                                                {
22821                                                  if (((word >> 16) & 0x1) == 0)
22822                                                    {
22823                                                      /* 33222222222211111111110000000000
22824                                                         10987654321098765432109876543210
22825                                                         xxx11110xx1xxxx0101010xxxxxxxxxx
22826                                                         cmlt.  */
22827                                                      return 484;
22828                                                    }
22829                                                  else
22830                                                    {
22831                                                      if (((word >> 19) & 0x1) == 0)
22832                                                        {
22833                                                          if (((word >> 23) & 0x1) == 0)
22834                                                            {
22835                                                              if (((word >> 29) & 0x1) == 0)
22836                                                                {
22837                                                                  /* 33222222222211111111110000000000
22838                                                                     10987654321098765432109876543210
22839                                                                     xx0111100x1x0xx1101010xxxxxxxxxx
22840                                                                     fcvtns.  */
22841                                                                  return 487;
22842                                                                }
22843                                                              else
22844                                                                {
22845                                                                  /* 33222222222211111111110000000000
22846                                                                     10987654321098765432109876543210
22847                                                                     xx1111100x1x0xx1101010xxxxxxxxxx
22848                                                                     fcvtnu.  */
22849                                                                  return 517;
22850                                                                }
22851                                                            }
22852                                                          else
22853                                                            {
22854                                                              if (((word >> 29) & 0x1) == 0)
22855                                                                {
22856                                                                  /* 33222222222211111111110000000000
22857                                                                     10987654321098765432109876543210
22858                                                                     xx0111101x1x0xx1101010xxxxxxxxxx
22859                                                                     fcvtps.  */
22860                                                                  return 501;
22861                                                                }
22862                                                              else
22863                                                                {
22864                                                                  /* 33222222222211111111110000000000
22865                                                                     10987654321098765432109876543210
22866                                                                     xx1111101x1x0xx1101010xxxxxxxxxx
22867                                                                     fcvtpu.  */
22868                                                                  return 529;
22869                                                                }
22870                                                            }
22871                                                        }
22872                                                      else
22873                                                        {
22874                                                          if (((word >> 23) & 0x1) == 0)
22875                                                            {
22876                                                              if (((word >> 29) & 0x1) == 0)
22877                                                                {
22878                                                                  /* 33222222222211111111110000000000
22879                                                                     10987654321098765432109876543210
22880                                                                     xx0111100x1x1xx1101010xxxxxxxxxx
22881                                                                     fcvtns.  */
22882                                                                  return 488;
22883                                                                }
22884                                                              else
22885                                                                {
22886                                                                  /* 33222222222211111111110000000000
22887                                                                     10987654321098765432109876543210
22888                                                                     xx1111100x1x1xx1101010xxxxxxxxxx
22889                                                                     fcvtnu.  */
22890                                                                  return 518;
22891                                                                }
22892                                                            }
22893                                                          else
22894                                                            {
22895                                                              if (((word >> 29) & 0x1) == 0)
22896                                                                {
22897                                                                  /* 33222222222211111111110000000000
22898                                                                     10987654321098765432109876543210
22899                                                                     xx0111101x1x1xx1101010xxxxxxxxxx
22900                                                                     fcvtps.  */
22901                                                                  return 502;
22902                                                                }
22903                                                              else
22904                                                                {
22905                                                                  /* 33222222222211111111110000000000
22906                                                                     10987654321098765432109876543210
22907                                                                     xx1111101x1x1xx1101010xxxxxxxxxx
22908                                                                     fcvtpu.  */
22909                                                                  return 530;
22910                                                                }
22911                                                            }
22912                                                        }
22913                                                    }
22914                                                }
22915                                            }
22916                                          else
22917                                            {
22918                                              if (((word >> 15) & 0x1) == 0)
22919                                                {
22920                                                  if (((word >> 29) & 0x1) == 0)
22921                                                    {
22922                                                      /* 33222222222211111111110000000000
22923                                                         10987654321098765432109876543210
22924                                                         xx011110xx1xxxxx011010xxxxxxxxxx
22925                                                         fmaxnm.  */
22926                                                      return 852;
22927                                                    }
22928                                                  else
22929                                                    {
22930                                                      /* 33222222222211111111110000000000
22931                                                         10987654321098765432109876543210
22932                                                         xx111110xx1xxxxx011010xxxxxxxxxx
22933                                                         fcvtxn.  */
22934                                                      return 516;
22935                                                    }
22936                                                }
22937                                              else
22938                                                {
22939                                                  if (((word >> 19) & 0x1) == 0)
22940                                                    {
22941                                                      /* 33222222222211111111110000000000
22942                                                         10987654321098765432109876543210
22943                                                         xxx11110xx1x0xxx111010xxxxxxxxxx
22944                                                         fcmlt.  */
22945                                                      return 499;
22946                                                    }
22947                                                  else
22948                                                    {
22949                                                      /* 33222222222211111111110000000000
22950                                                         10987654321098765432109876543210
22951                                                         xxx11110xx1x1xxx111010xxxxxxxxxx
22952                                                         fcmlt.  */
22953                                                      return 500;
22954                                                    }
22955                                                }
22956                                            }
22957                                        }
22958                                    }
22959                                  else
22960                                    {
22961                                      if (((word >> 13) & 0x1) == 0)
22962                                        {
22963                                          if (((word >> 14) & 0x1) == 0)
22964                                            {
22965                                              if (((word >> 15) & 0x1) == 0)
22966                                                {
22967                                                  if (((word >> 30) & 0x1) == 0)
22968                                                    {
22969                                                      /* 33222222222211111111110000000000
22970                                                         10987654321098765432109876543210
22971                                                         x0x11110xx1xxxxx000110xxxxxxxxxx
22972                                                         fdiv.  */
22973                                                      return 842;
22974                                                    }
22975                                                  else
22976                                                    {
22977                                                      /* 33222222222211111111110000000000
22978                                                         10987654321098765432109876543210
22979                                                         x1x11110xx1xxxxx000110xxxxxxxxxx
22980                                                         sha1su1.  */
22981                                                      return 676;
22982                                                    }
22983                                                }
22984                                              else
22985                                                {
22986                                                  if (((word >> 29) & 0x1) == 0)
22987                                                    {
22988                                                      /* 33222222222211111111110000000000
22989                                                         10987654321098765432109876543210
22990                                                         xx011110xx1xxxxx100110xxxxxxxxxx
22991                                                         cmeq.  */
22992                                                      return 483;
22993                                                    }
22994                                                  else
22995                                                    {
22996                                                      /* 33222222222211111111110000000000
22997                                                         10987654321098765432109876543210
22998                                                         xx111110xx1xxxxx100110xxxxxxxxxx
22999                                                         cmle.  */
23000                                                      return 512;
23001                                                    }
23002                                                }
23003                                            }
23004                                          else
23005                                            {
23006                                              if (((word >> 15) & 0x1) == 0)
23007                                                {
23008                                                  /* 33222222222211111111110000000000
23009                                                     10987654321098765432109876543210
23010                                                     xxx11110xx1xxxxx010110xxxxxxxxxx
23011                                                     fmin.  */
23012                                                  return 850;
23013                                                }
23014                                              else
23015                                                {
23016                                                  if (((word >> 16) & 0x1) == 0)
23017                                                    {
23018                                                      if (((word >> 19) & 0x1) == 0)
23019                                                        {
23020                                                          if (((word >> 20) & 0x1) == 0)
23021                                                            {
23022                                                              if (((word >> 29) & 0x1) == 0)
23023                                                                {
23024                                                                  /* 33222222222211111111110000000000
23025                                                                     10987654321098765432109876543210
23026                                                                     xx011110xx100xx0110110xxxxxxxxxx
23027                                                                     fcmeq.  */
23028                                                                  return 497;
23029                                                                }
23030                                                              else
23031                                                                {
23032                                                                  /* 33222222222211111111110000000000
23033                                                                     10987654321098765432109876543210
23034                                                                     xx111110xx100xx0110110xxxxxxxxxx
23035                                                                     fcmle.  */
23036                                                                  return 527;
23037                                                                }
23038                                                            }
23039                                                          else
23040                                                            {
23041                                                              if (((word >> 29) & 0x1) == 0)
23042                                                                {
23043                                                                  /* 33222222222211111111110000000000
23044                                                                     10987654321098765432109876543210
23045                                                                     xx011110xx110xx0110110xxxxxxxxxx
23046                                                                     faddp.  */
23047                                                                  return 541;
23048                                                                }
23049                                                              else
23050                                                                {
23051                                                                  /* 33222222222211111111110000000000
23052                                                                     10987654321098765432109876543210
23053                                                                     xx111110xx110xx0110110xxxxxxxxxx
23054                                                                     faddp.  */
23055                                                                  return 540;
23056                                                                }
23057                                                            }
23058                                                        }
23059                                                      else
23060                                                        {
23061                                                          if (((word >> 29) & 0x1) == 0)
23062                                                            {
23063                                                              /* 33222222222211111111110000000000
23064                                                                 10987654321098765432109876543210
23065                                                                 xx011110xx1x1xx0110110xxxxxxxxxx
23066                                                                 fcmeq.  */
23067                                                              return 498;
23068                                                            }
23069                                                          else
23070                                                            {
23071                                                              /* 33222222222211111111110000000000
23072                                                                 10987654321098765432109876543210
23073                                                                 xx111110xx1x1xx0110110xxxxxxxxxx
23074                                                                 fcmle.  */
23075                                                              return 528;
23076                                                            }
23077                                                        }
23078                                                    }
23079                                                  else
23080                                                    {
23081                                                      if (((word >> 19) & 0x1) == 0)
23082                                                        {
23083                                                          if (((word >> 23) & 0x1) == 0)
23084                                                            {
23085                                                              if (((word >> 29) & 0x1) == 0)
23086                                                                {
23087                                                                  /* 33222222222211111111110000000000
23088                                                                     10987654321098765432109876543210
23089                                                                     xx0111100x1x0xx1110110xxxxxxxxxx
23090                                                                     scvtf.  */
23091                                                                  return 493;
23092                                                                }
23093                                                              else
23094                                                                {
23095                                                                  /* 33222222222211111111110000000000
23096                                                                     10987654321098765432109876543210
23097                                                                     xx1111100x1x0xx1110110xxxxxxxxxx
23098                                                                     ucvtf.  */
23099                                                                  return 523;
23100                                                                }
23101                                                            }
23102                                                          else
23103                                                            {
23104                                                              if (((word >> 29) & 0x1) == 0)
23105                                                                {
23106                                                                  /* 33222222222211111111110000000000
23107                                                                     10987654321098765432109876543210
23108                                                                     xx0111101x1x0xx1110110xxxxxxxxxx
23109                                                                     frecpe.  */
23110                                                                  return 505;
23111                                                                }
23112                                                              else
23113                                                                {
23114                                                                  /* 33222222222211111111110000000000
23115                                                                     10987654321098765432109876543210
23116                                                                     xx1111101x1x0xx1110110xxxxxxxxxx
23117                                                                     frsqrte.  */
23118                                                                  return 533;
23119                                                                }
23120                                                            }
23121                                                        }
23122                                                      else
23123                                                        {
23124                                                          if (((word >> 23) & 0x1) == 0)
23125                                                            {
23126                                                              if (((word >> 29) & 0x1) == 0)
23127                                                                {
23128                                                                  /* 33222222222211111111110000000000
23129                                                                     10987654321098765432109876543210
23130                                                                     xx0111100x1x1xx1110110xxxxxxxxxx
23131                                                                     scvtf.  */
23132                                                                  return 494;
23133                                                                }
23134                                                              else
23135                                                                {
23136                                                                  /* 33222222222211111111110000000000
23137                                                                     10987654321098765432109876543210
23138                                                                     xx1111100x1x1xx1110110xxxxxxxxxx
23139                                                                     ucvtf.  */
23140                                                                  return 524;
23141                                                                }
23142                                                            }
23143                                                          else
23144                                                            {
23145                                                              if (((word >> 29) & 0x1) == 0)
23146                                                                {
23147                                                                  /* 33222222222211111111110000000000
23148                                                                     10987654321098765432109876543210
23149                                                                     xx0111101x1x1xx1110110xxxxxxxxxx
23150                                                                     frecpe.  */
23151                                                                  return 506;
23152                                                                }
23153                                                              else
23154                                                                {
23155                                                                  /* 33222222222211111111110000000000
23156                                                                     10987654321098765432109876543210
23157                                                                     xx1111101x1x1xx1110110xxxxxxxxxx
23158                                                                     frsqrte.  */
23159                                                                  return 534;
23160                                                                }
23161                                                            }
23162                                                        }
23163                                                    }
23164                                                }
23165                                            }
23166                                        }
23167                                      else
23168                                        {
23169                                          if (((word >> 14) & 0x1) == 0)
23170                                            {
23171                                              if (((word >> 15) & 0x1) == 0)
23172                                                {
23173                                                  if (((word >> 29) & 0x1) == 0)
23174                                                    {
23175                                                      if (((word >> 30) & 0x1) == 0)
23176                                                        {
23177                                                          /* 33222222222211111111110000000000
23178                                                             10987654321098765432109876543210
23179                                                             x0011110xx1xxxxx001110xxxxxxxxxx
23180                                                             fsub.  */
23181                                                          return 846;
23182                                                        }
23183                                                      else
23184                                                        {
23185                                                          /* 33222222222211111111110000000000
23186                                                             10987654321098765432109876543210
23187                                                             x1011110xx1xxxxx001110xxxxxxxxxx
23188                                                             suqadd.  */
23189                                                          return 480;
23190                                                        }
23191                                                    }
23192                                                  else
23193                                                    {
23194                                                      /* 33222222222211111111110000000000
23195                                                         10987654321098765432109876543210
23196                                                         xx111110xx1xxxxx001110xxxxxxxxxx
23197                                                         usqadd.  */
23198                                                      return 509;
23199                                                    }
23200                                                }
23201                                              else
23202                                                {
23203                                                  if (((word >> 16) & 0x1) == 0)
23204                                                    {
23205                                                      if (((word >> 29) & 0x1) == 0)
23206                                                        {
23207                                                          /* 33222222222211111111110000000000
23208                                                             10987654321098765432109876543210
23209                                                             xx011110xx1xxxx0101110xxxxxxxxxx
23210                                                             abs.  */
23211                                                          return 485;
23212                                                        }
23213                                                      else
23214                                                        {
23215                                                          /* 33222222222211111111110000000000
23216                                                             10987654321098765432109876543210
23217                                                             xx111110xx1xxxx0101110xxxxxxxxxx
23218                                                             neg.  */
23219                                                          return 513;
23220                                                        }
23221                                                    }
23222                                                  else
23223                                                    {
23224                                                      if (((word >> 19) & 0x1) == 0)
23225                                                        {
23226                                                          if (((word >> 20) & 0x1) == 0)
23227                                                            {
23228                                                              if (((word >> 23) & 0x1) == 0)
23229                                                                {
23230                                                                  if (((word >> 29) & 0x1) == 0)
23231                                                                    {
23232                                                                      /* 33222222222211111111110000000000
23233                                                                         10987654321098765432109876543210
23234                                                                         xx0111100x100xx1101110xxxxxxxxxx
23235                                                                         fcvtms.  */
23236                                                                      return 489;
23237                                                                    }
23238                                                                  else
23239                                                                    {
23240                                                                      /* 33222222222211111111110000000000
23241                                                                         10987654321098765432109876543210
23242                                                                         xx1111100x100xx1101110xxxxxxxxxx
23243                                                                         fcvtmu.  */
23244                                                                      return 519;
23245                                                                    }
23246                                                                }
23247                                                              else
23248                                                                {
23249                                                                  if (((word >> 29) & 0x1) == 0)
23250                                                                    {
23251                                                                      /* 33222222222211111111110000000000
23252                                                                         10987654321098765432109876543210
23253                                                                         xx0111101x100xx1101110xxxxxxxxxx
23254                                                                         fcvtzs.  */
23255                                                                      return 503;
23256                                                                    }
23257                                                                  else
23258                                                                    {
23259                                                                      /* 33222222222211111111110000000000
23260                                                                         10987654321098765432109876543210
23261                                                                         xx1111101x100xx1101110xxxxxxxxxx
23262                                                                         fcvtzu.  */
23263                                                                      return 531;
23264                                                                    }
23265                                                                }
23266                                                            }
23267                                                          else
23268                                                            {
23269                                                              /* 33222222222211111111110000000000
23270                                                                 10987654321098765432109876543210
23271                                                                 xxx11110xx110xx1101110xxxxxxxxxx
23272                                                                 addp.  */
23273                                                              return 537;
23274                                                            }
23275                                                        }
23276                                                      else
23277                                                        {
23278                                                          if (((word >> 23) & 0x1) == 0)
23279                                                            {
23280                                                              if (((word >> 29) & 0x1) == 0)
23281                                                                {
23282                                                                  /* 33222222222211111111110000000000
23283                                                                     10987654321098765432109876543210
23284                                                                     xx0111100x1x1xx1101110xxxxxxxxxx
23285                                                                     fcvtms.  */
23286                                                                  return 490;
23287                                                                }
23288                                                              else
23289                                                                {
23290                                                                  /* 33222222222211111111110000000000
23291                                                                     10987654321098765432109876543210
23292                                                                     xx1111100x1x1xx1101110xxxxxxxxxx
23293                                                                     fcvtmu.  */
23294                                                                  return 520;
23295                                                                }
23296                                                            }
23297                                                          else
23298                                                            {
23299                                                              if (((word >> 29) & 0x1) == 0)
23300                                                                {
23301                                                                  /* 33222222222211111111110000000000
23302                                                                     10987654321098765432109876543210
23303                                                                     xx0111101x1x1xx1101110xxxxxxxxxx
23304                                                                     fcvtzs.  */
23305                                                                  return 504;
23306                                                                }
23307                                                              else
23308                                                                {
23309                                                                  /* 33222222222211111111110000000000
23310                                                                     10987654321098765432109876543210
23311                                                                     xx1111101x1x1xx1101110xxxxxxxxxx
23312                                                                     fcvtzu.  */
23313                                                                  return 532;
23314                                                                }
23315                                                            }
23316                                                        }
23317                                                    }
23318                                                }
23319                                            }
23320                                          else
23321                                            {
23322                                              if (((word >> 15) & 0x1) == 0)
23323                                                {
23324                                                  if (((word >> 29) & 0x1) == 0)
23325                                                    {
23326                                                      if (((word >> 30) & 0x1) == 0)
23327                                                        {
23328                                                          /* 33222222222211111111110000000000
23329                                                             10987654321098765432109876543210
23330                                                             x0011110xx1xxxxx011110xxxxxxxxxx
23331                                                             fminnm.  */
23332                                                          return 854;
23333                                                        }
23334                                                      else
23335                                                        {
23336                                                          /* 33222222222211111111110000000000
23337                                                             10987654321098765432109876543210
23338                                                             x1011110xx1xxxxx011110xxxxxxxxxx
23339                                                             sqabs.  */
23340                                                          return 481;
23341                                                        }
23342                                                    }
23343                                                  else
23344                                                    {
23345                                                      /* 33222222222211111111110000000000
23346                                                         10987654321098765432109876543210
23347                                                         xx111110xx1xxxxx011110xxxxxxxxxx
23348                                                         sqneg.  */
23349                                                      return 510;
23350                                                    }
23351                                                }
23352                                              else
23353                                                {
23354                                                  if (((word >> 16) & 0x1) == 0)
23355                                                    {
23356                                                      if (((word >> 23) & 0x1) == 0)
23357                                                        {
23358                                                          if (((word >> 29) & 0x1) == 0)
23359                                                            {
23360                                                              /* 33222222222211111111110000000000
23361                                                                 10987654321098765432109876543210
23362                                                                 xx0111100x1xxxx0111110xxxxxxxxxx
23363                                                                 fmaxp.  */
23364                                                              return 543;
23365                                                            }
23366                                                          else
23367                                                            {
23368                                                              /* 33222222222211111111110000000000
23369                                                                 10987654321098765432109876543210
23370                                                                 xx1111100x1xxxx0111110xxxxxxxxxx
23371                                                                 fmaxp.  */
23372                                                              return 542;
23373                                                            }
23374                                                        }
23375                                                      else
23376                                                        {
23377                                                          if (((word >> 29) & 0x1) == 0)
23378                                                            {
23379                                                              /* 33222222222211111111110000000000
23380                                                                 10987654321098765432109876543210
23381                                                                 xx0111101x1xxxx0111110xxxxxxxxxx
23382                                                                 fminp.  */
23383                                                              return 547;
23384                                                            }
23385                                                          else
23386                                                            {
23387                                                              /* 33222222222211111111110000000000
23388                                                                 10987654321098765432109876543210
23389                                                                 xx1111101x1xxxx0111110xxxxxxxxxx
23390                                                                 fminp.  */
23391                                                              return 546;
23392                                                            }
23393                                                        }
23394                                                    }
23395                                                  else
23396                                                    {
23397                                                      if (((word >> 19) & 0x1) == 0)
23398                                                        {
23399                                                          /* 33222222222211111111110000000000
23400                                                             10987654321098765432109876543210
23401                                                             xxx11110xx1x0xx1111110xxxxxxxxxx
23402                                                             frecpx.  */
23403                                                          return 507;
23404                                                        }
23405                                                      else
23406                                                        {
23407                                                          /* 33222222222211111111110000000000
23408                                                             10987654321098765432109876543210
23409                                                             xxx11110xx1x1xx1111110xxxxxxxxxx
23410                                                             frecpx.  */
23411                                                          return 508;
23412                                                        }
23413                                                    }
23414                                                }
23415                                            }
23416                                        }
23417                                    }
23418                                }
23419                            }
23420                          else
23421                            {
23422                              if (((word >> 11) & 0x1) == 0)
23423                                {
23424                                  if (((word >> 29) & 0x1) == 0)
23425                                    {
23426                                      if (((word >> 30) & 0x1) == 0)
23427                                        {
23428                                          if (((word >> 4) & 0x1) == 0)
23429                                            {
23430                                              /* 33222222222211111111110000000000
23431                                                 10987654321098765432109876543210
23432                                                 x0011110xx1xxxxxxxxx01xxxxx0xxxx
23433                                                 fccmp.  */
23434                                              return 799;
23435                                            }
23436                                          else
23437                                            {
23438                                              /* 33222222222211111111110000000000
23439                                                 10987654321098765432109876543210
23440                                                 x0011110xx1xxxxxxxxx01xxxxx1xxxx
23441                                                 fccmpe.  */
23442                                              return 801;
23443                                            }
23444                                        }
23445                                      else
23446                                        {
23447                                          if (((word >> 12) & 0x1) == 0)
23448                                            {
23449                                              if (((word >> 13) & 0x1) == 0)
23450                                                {
23451                                                  if (((word >> 14) & 0x1) == 0)
23452                                                    {
23453                                                      /* 33222222222211111111110000000000
23454                                                         10987654321098765432109876543210
23455                                                         x1011110xx1xxxxxx00001xxxxxxxxxx
23456                                                         add.  */
23457                                                      return 565;
23458                                                    }
23459                                                  else
23460                                                    {
23461                                                      /* 33222222222211111111110000000000
23462                                                         10987654321098765432109876543210
23463                                                         x1011110xx1xxxxxx10001xxxxxxxxxx
23464                                                         sshl.  */
23465                                                      return 563;
23466                                                    }
23467                                                }
23468                                              else
23469                                                {
23470                                                  /* 33222222222211111111110000000000
23471                                                     10987654321098765432109876543210
23472                                                     x1011110xx1xxxxxxx1001xxxxxxxxxx
23473                                                     fcmeq.  */
23474                                                  return 555;
23475                                                }
23476                                            }
23477                                          else
23478                                            {
23479                                              if (((word >> 13) & 0x1) == 0)
23480                                                {
23481                                                  /* 33222222222211111111110000000000
23482                                                     10987654321098765432109876543210
23483                                                     x1011110xx1xxxxxxx0101xxxxxxxxxx
23484                                                     srshl.  */
23485                                                  return 564;
23486                                                }
23487                                              else
23488                                                {
23489                                                  if (((word >> 15) & 0x1) == 0)
23490                                                    {
23491                                                      /* 33222222222211111111110000000000
23492                                                         10987654321098765432109876543210
23493                                                         x1011110xx1xxxxx0x1101xxxxxxxxxx
23494                                                         cmgt.  */
23495                                                      return 561;
23496                                                    }
23497                                                  else
23498                                                    {
23499                                                      /* 33222222222211111111110000000000
23500                                                         10987654321098765432109876543210
23501                                                         x1011110xx1xxxxx1x1101xxxxxxxxxx
23502                                                         sqdmulh.  */
23503                                                      return 552;
23504                                                    }
23505                                                }
23506                                            }
23507                                        }
23508                                    }
23509                                  else
23510                                    {
23511                                      if (((word >> 12) & 0x1) == 0)
23512                                        {
23513                                          if (((word >> 13) & 0x1) == 0)
23514                                            {
23515                                              if (((word >> 14) & 0x1) == 0)
23516                                                {
23517                                                  /* 33222222222211111111110000000000
23518                                                     10987654321098765432109876543210
23519                                                     xx111110xx1xxxxxx00001xxxxxxxxxx
23520                                                     sub.  */
23521                                                  return 586;
23522                                                }
23523                                              else
23524                                                {
23525                                                  /* 33222222222211111111110000000000
23526                                                     10987654321098765432109876543210
23527                                                     xx111110xx1xxxxxx10001xxxxxxxxxx
23528                                                     ushl.  */
23529                                                  return 584;
23530                                                }
23531                                            }
23532                                          else
23533                                            {
23534                                              if (((word >> 23) & 0x1) == 0)
23535                                                {
23536                                                  /* 33222222222211111111110000000000
23537                                                     10987654321098765432109876543210
23538                                                     xx1111100x1xxxxxxx1001xxxxxxxxxx
23539                                                     fcmge.  */
23540                                                  return 572;
23541                                                }
23542                                              else
23543                                                {
23544                                                  /* 33222222222211111111110000000000
23545                                                     10987654321098765432109876543210
23546                                                     xx1111101x1xxxxxxx1001xxxxxxxxxx
23547                                                     fcmgt.  */
23548                                                  return 578;
23549                                                }
23550                                            }
23551                                        }
23552                                      else
23553                                        {
23554                                          if (((word >> 13) & 0x1) == 0)
23555                                            {
23556                                              if (((word >> 15) & 0x1) == 0)
23557                                                {
23558                                                  /* 33222222222211111111110000000000
23559                                                     10987654321098765432109876543210
23560                                                     xx111110xx1xxxxx0x0101xxxxxxxxxx
23561                                                     urshl.  */
23562                                                  return 585;
23563                                                }
23564                                              else
23565                                                {
23566                                                  /* 33222222222211111111110000000000
23567                                                     10987654321098765432109876543210
23568                                                     xx111110xx1xxxxx1x0101xxxxxxxxxx
23569                                                     fabd.  */
23570                                                  return 576;
23571                                                }
23572                                            }
23573                                          else
23574                                            {
23575                                              if (((word >> 15) & 0x1) == 0)
23576                                                {
23577                                                  /* 33222222222211111111110000000000
23578                                                     10987654321098765432109876543210
23579                                                     xx111110xx1xxxxx0x1101xxxxxxxxxx
23580                                                     cmhi.  */
23581                                                  return 582;
23582                                                }
23583                                              else
23584                                                {
23585                                                  /* 33222222222211111111110000000000
23586                                                     10987654321098765432109876543210
23587                                                     xx111110xx1xxxxx1x1101xxxxxxxxxx
23588                                                     sqrdmulh.  */
23589                                                  return 571;
23590                                                }
23591                                            }
23592                                        }
23593                                    }
23594                                }
23595                              else
23596                                {
23597                                  if (((word >> 29) & 0x1) == 0)
23598                                    {
23599                                      if (((word >> 30) & 0x1) == 0)
23600                                        {
23601                                          /* 33222222222211111111110000000000
23602                                             10987654321098765432109876543210
23603                                             x0011110xx1xxxxxxxxx11xxxxxxxxxx
23604                                             fcsel.  */
23605                                          return 868;
23606                                        }
23607                                      else
23608                                        {
23609                                          if (((word >> 12) & 0x1) == 0)
23610                                            {
23611                                              if (((word >> 13) & 0x1) == 0)
23612                                                {
23613                                                  if (((word >> 14) & 0x1) == 0)
23614                                                    {
23615                                                      if (((word >> 15) & 0x1) == 0)
23616                                                        {
23617                                                          /* 33222222222211111111110000000000
23618                                                             10987654321098765432109876543210
23619                                                             x1011110xx1xxxxx000011xxxxxxxxxx
23620                                                             sqadd.  */
23621                                                          return 548;
23622                                                        }
23623                                                      else
23624                                                        {
23625                                                          /* 33222222222211111111110000000000
23626                                                             10987654321098765432109876543210
23627                                                             x1011110xx1xxxxx100011xxxxxxxxxx
23628                                                             cmtst.  */
23629                                                          return 566;
23630                                                        }
23631                                                    }
23632                                                  else
23633                                                    {
23634                                                      /* 33222222222211111111110000000000
23635                                                         10987654321098765432109876543210
23636                                                         x1011110xx1xxxxxx10011xxxxxxxxxx
23637                                                         sqshl.  */
23638                                                      return 550;
23639                                                    }
23640                                                }
23641                                              else
23642                                                {
23643                                                  /* 33222222222211111111110000000000
23644                                                     10987654321098765432109876543210
23645                                                     x1011110xx1xxxxxxx1011xxxxxxxxxx
23646                                                     sqsub.  */
23647                                                  return 549;
23648                                                }
23649                                            }
23650                                          else
23651                                            {
23652                                              if (((word >> 13) & 0x1) == 0)
23653                                                {
23654                                                  if (((word >> 15) & 0x1) == 0)
23655                                                    {
23656                                                      /* 33222222222211111111110000000000
23657                                                         10987654321098765432109876543210
23658                                                         x1011110xx1xxxxx0x0111xxxxxxxxxx
23659                                                         sqrshl.  */
23660                                                      return 551;
23661                                                    }
23662                                                  else
23663                                                    {
23664                                                      /* 33222222222211111111110000000000
23665                                                         10987654321098765432109876543210
23666                                                         x1011110xx1xxxxx1x0111xxxxxxxxxx
23667                                                         fmulx.  */
23668                                                      return 553;
23669                                                    }
23670                                                }
23671                                              else
23672                                                {
23673                                                  if (((word >> 14) & 0x1) == 0)
23674                                                    {
23675                                                      /* 33222222222211111111110000000000
23676                                                         10987654321098765432109876543210
23677                                                         x1011110xx1xxxxxx01111xxxxxxxxxx
23678                                                         cmge.  */
23679                                                      return 562;
23680                                                    }
23681                                                  else
23682                                                    {
23683                                                      if (((word >> 23) & 0x1) == 0)
23684                                                        {
23685                                                          /* 33222222222211111111110000000000
23686                                                             10987654321098765432109876543210
23687                                                             x10111100x1xxxxxx11111xxxxxxxxxx
23688                                                             frecps.  */
23689                                                          return 557;
23690                                                        }
23691                                                      else
23692                                                        {
23693                                                          /* 33222222222211111111110000000000
23694                                                             10987654321098765432109876543210
23695                                                             x10111101x1xxxxxx11111xxxxxxxxxx
23696                                                             frsqrts.  */
23697                                                          return 559;
23698                                                        }
23699                                                    }
23700                                                }
23701                                            }
23702                                        }
23703                                    }
23704                                  else
23705                                    {
23706                                      if (((word >> 12) & 0x1) == 0)
23707                                        {
23708                                          if (((word >> 13) & 0x1) == 0)
23709                                            {
23710                                              if (((word >> 14) & 0x1) == 0)
23711                                                {
23712                                                  if (((word >> 15) & 0x1) == 0)
23713                                                    {
23714                                                      /* 33222222222211111111110000000000
23715                                                         10987654321098765432109876543210
23716                                                         xx111110xx1xxxxx000011xxxxxxxxxx
23717                                                         uqadd.  */
23718                                                      return 567;
23719                                                    }
23720                                                  else
23721                                                    {
23722                                                      /* 33222222222211111111110000000000
23723                                                         10987654321098765432109876543210
23724                                                         xx111110xx1xxxxx100011xxxxxxxxxx
23725                                                         cmeq.  */
23726                                                      return 587;
23727                                                    }
23728                                                }
23729                                              else
23730                                                {
23731                                                  /* 33222222222211111111110000000000
23732                                                     10987654321098765432109876543210
23733                                                     xx111110xx1xxxxxx10011xxxxxxxxxx
23734                                                     uqshl.  */
23735                                                  return 569;
23736                                                }
23737                                            }
23738                                          else
23739                                            {
23740                                              if (((word >> 14) & 0x1) == 0)
23741                                                {
23742                                                  /* 33222222222211111111110000000000
23743                                                     10987654321098765432109876543210
23744                                                     xx111110xx1xxxxxx01011xxxxxxxxxx
23745                                                     uqsub.  */
23746                                                  return 568;
23747                                                }
23748                                              else
23749                                                {
23750                                                  if (((word >> 23) & 0x1) == 0)
23751                                                    {
23752                                                      /* 33222222222211111111110000000000
23753                                                         10987654321098765432109876543210
23754                                                         xx1111100x1xxxxxx11011xxxxxxxxxx
23755                                                         facge.  */
23756                                                      return 574;
23757                                                    }
23758                                                  else
23759                                                    {
23760                                                      /* 33222222222211111111110000000000
23761                                                         10987654321098765432109876543210
23762                                                         xx1111101x1xxxxxx11011xxxxxxxxxx
23763                                                         facgt.  */
23764                                                      return 580;
23765                                                    }
23766                                                }
23767                                            }
23768                                        }
23769                                      else
23770                                        {
23771                                          if (((word >> 13) & 0x1) == 0)
23772                                            {
23773                                              /* 33222222222211111111110000000000
23774                                                 10987654321098765432109876543210
23775                                                 xx111110xx1xxxxxxx0111xxxxxxxxxx
23776                                                 uqrshl.  */
23777                                              return 570;
23778                                            }
23779                                          else
23780                                            {
23781                                              /* 33222222222211111111110000000000
23782                                                 10987654321098765432109876543210
23783                                                 xx111110xx1xxxxxxx1111xxxxxxxxxx
23784                                                 cmhs.  */
23785                                              return 583;
23786                                            }
23787                                        }
23788                                    }
23789                                }
23790                            }
23791                        }
23792                    }
23793                }
23794              else
23795                {
23796                  if (((word >> 15) & 0x1) == 0)
23797                    {
23798                      if (((word >> 28) & 0x1) == 0)
23799                        {
23800                          if (((word >> 10) & 0x1) == 0)
23801                            {
23802                              if (((word >> 12) & 0x1) == 0)
23803                                {
23804                                  if (((word >> 13) & 0x1) == 0)
23805                                    {
23806                                      if (((word >> 14) & 0x1) == 0)
23807                                        {
23808                                          if (((word >> 29) & 0x1) == 0)
23809                                            {
23810                                              if (((word >> 30) & 0x1) == 0)
23811                                                {
23812                                                  /* 33222222222211111111110000000000
23813                                                     10987654321098765432109876543210
23814                                                     x0001111xxxxxxxx0000x0xxxxxxxxxx
23815                                                     fmlal.  */
23816                                                  return 2443;
23817                                                }
23818                                              else
23819                                                {
23820                                                  /* 33222222222211111111110000000000
23821                                                     10987654321098765432109876543210
23822                                                     x1001111xxxxxxxx0000x0xxxxxxxxxx
23823                                                     fmlal.  */
23824                                                  return 2447;
23825                                                }
23826                                            }
23827                                          else
23828                                            {
23829                                              /* 33222222222211111111110000000000
23830                                                 10987654321098765432109876543210
23831                                                 xx101111xxxxxxxx0000x0xxxxxxxxxx
23832                                                 mla.  */
23833                                              return 119;
23834                                            }
23835                                        }
23836                                      else
23837                                        {
23838                                          if (((word >> 29) & 0x1) == 0)
23839                                            {
23840                                              if (((word >> 30) & 0x1) == 0)
23841                                                {
23842                                                  /* 33222222222211111111110000000000
23843                                                     10987654321098765432109876543210
23844                                                     x0001111xxxxxxxx0100x0xxxxxxxxxx
23845                                                     fmlsl.  */
23846                                                  return 2444;
23847                                                }
23848                                              else
23849                                                {
23850                                                  /* 33222222222211111111110000000000
23851                                                     10987654321098765432109876543210
23852                                                     x1001111xxxxxxxx0100x0xxxxxxxxxx
23853                                                     fmlsl.  */
23854                                                  return 2448;
23855                                                }
23856                                            }
23857                                          else
23858                                            {
23859                                              /* 33222222222211111111110000000000
23860                                                 10987654321098765432109876543210
23861                                                 xx101111xxxxxxxx0100x0xxxxxxxxxx
23862                                                 mls.  */
23863                                              return 122;
23864                                            }
23865                                        }
23866                                    }
23867                                  else
23868                                    {
23869                                      if (((word >> 14) & 0x1) == 0)
23870                                        {
23871                                          if (((word >> 29) & 0x1) == 0)
23872                                            {
23873                                              if (((word >> 30) & 0x1) == 0)
23874                                                {
23875                                                  /* 33222222222211111111110000000000
23876                                                     10987654321098765432109876543210
23877                                                     x0001111xxxxxxxx0010x0xxxxxxxxxx
23878                                                     smlal.  */
23879                                                  return 98;
23880                                                }
23881                                              else
23882                                                {
23883                                                  /* 33222222222211111111110000000000
23884                                                     10987654321098765432109876543210
23885                                                     x1001111xxxxxxxx0010x0xxxxxxxxxx
23886                                                     smlal2.  */
23887                                                  return 99;
23888                                                }
23889                                            }
23890                                          else
23891                                            {
23892                                              if (((word >> 30) & 0x1) == 0)
23893                                                {
23894                                                  /* 33222222222211111111110000000000
23895                                                     10987654321098765432109876543210
23896                                                     x0101111xxxxxxxx0010x0xxxxxxxxxx
23897                                                     umlal.  */
23898                                                  return 120;
23899                                                }
23900                                              else
23901                                                {
23902                                                  /* 33222222222211111111110000000000
23903                                                     10987654321098765432109876543210
23904                                                     x1101111xxxxxxxx0010x0xxxxxxxxxx
23905                                                     umlal2.  */
23906                                                  return 121;
23907                                                }
23908                                            }
23909                                        }
23910                                      else
23911                                        {
23912                                          if (((word >> 29) & 0x1) == 0)
23913                                            {
23914                                              if (((word >> 30) & 0x1) == 0)
23915                                                {
23916                                                  /* 33222222222211111111110000000000
23917                                                     10987654321098765432109876543210
23918                                                     x0001111xxxxxxxx0110x0xxxxxxxxxx
23919                                                     smlsl.  */
23920                                                  return 102;
23921                                                }
23922                                              else
23923                                                {
23924                                                  /* 33222222222211111111110000000000
23925                                                     10987654321098765432109876543210
23926                                                     x1001111xxxxxxxx0110x0xxxxxxxxxx
23927                                                     smlsl2.  */
23928                                                  return 103;
23929                                                }
23930                                            }
23931                                          else
23932                                            {
23933                                              if (((word >> 30) & 0x1) == 0)
23934                                                {
23935                                                  /* 33222222222211111111110000000000
23936                                                     10987654321098765432109876543210
23937                                                     x0101111xxxxxxxx0110x0xxxxxxxxxx
23938                                                     umlsl.  */
23939                                                  return 123;
23940                                                }
23941                                              else
23942                                                {
23943                                                  /* 33222222222211111111110000000000
23944                                                     10987654321098765432109876543210
23945                                                     x1101111xxxxxxxx0110x0xxxxxxxxxx
23946                                                     umlsl2.  */
23947                                                  return 124;
23948                                                }
23949                                            }
23950                                        }
23951                                    }
23952                                }
23953                              else
23954                                {
23955                                  if (((word >> 29) & 0x1) == 0)
23956                                    {
23957                                      if (((word >> 13) & 0x1) == 0)
23958                                        {
23959                                          if (((word >> 14) & 0x1) == 0)
23960                                            {
23961                                              if (((word >> 23) & 0x1) == 0)
23962                                                {
23963                                                  /* 33222222222211111111110000000000
23964                                                     10987654321098765432109876543210
23965                                                     xx0011110xxxxxxx0001x0xxxxxxxxxx
23966                                                     fmla.  */
23967                                                  return 114;
23968                                                }
23969                                              else
23970                                                {
23971                                                  /* 33222222222211111111110000000000
23972                                                     10987654321098765432109876543210
23973                                                     xx0011111xxxxxxx0001x0xxxxxxxxxx
23974                                                     fmla.  */
23975                                                  return 113;
23976                                                }
23977                                            }
23978                                          else
23979                                            {
23980                                              if (((word >> 23) & 0x1) == 0)
23981                                                {
23982                                                  /* 33222222222211111111110000000000
23983                                                     10987654321098765432109876543210
23984                                                     xx0011110xxxxxxx0101x0xxxxxxxxxx
23985                                                     fmls.  */
23986                                                  return 116;
23987                                                }
23988                                              else
23989                                                {
23990                                                  /* 33222222222211111111110000000000
23991                                                     10987654321098765432109876543210
23992                                                     xx0011111xxxxxxx0101x0xxxxxxxxxx
23993                                                     fmls.  */
23994                                                  return 115;
23995                                                }
23996                                            }
23997                                        }
23998                                      else
23999                                        {
24000                                          if (((word >> 14) & 0x1) == 0)
24001                                            {
24002                                              if (((word >> 30) & 0x1) == 0)
24003                                                {
24004                                                  /* 33222222222211111111110000000000
24005                                                     10987654321098765432109876543210
24006                                                     x0001111xxxxxxxx0011x0xxxxxxxxxx
24007                                                     sqdmlal.  */
24008                                                  return 100;
24009                                                }
24010                                              else
24011                                                {
24012                                                  /* 33222222222211111111110000000000
24013                                                     10987654321098765432109876543210
24014                                                     x1001111xxxxxxxx0011x0xxxxxxxxxx
24015                                                     sqdmlal2.  */
24016                                                  return 101;
24017                                                }
24018                                            }
24019                                          else
24020                                            {
24021                                              if (((word >> 30) & 0x1) == 0)
24022                                                {
24023                                                  /* 33222222222211111111110000000000
24024                                                     10987654321098765432109876543210
24025                                                     x0001111xxxxxxxx0111x0xxxxxxxxxx
24026                                                     sqdmlsl.  */
24027                                                  return 104;
24028                                                }
24029                                              else
24030                                                {
24031                                                  /* 33222222222211111111110000000000
24032                                                     10987654321098765432109876543210
24033                                                     x1001111xxxxxxxx0111x0xxxxxxxxxx
24034                                                     sqdmlsl2.  */
24035                                                  return 105;
24036                                                }
24037                                            }
24038                                        }
24039                                    }
24040                                  else
24041                                    {
24042                                      /* 33222222222211111111110000000000
24043                                         10987654321098765432109876543210
24044                                         xx101111xxxxxxxx0xx1x0xxxxxxxxxx
24045                                         fcmla.  */
24046                                      return 131;
24047                                    }
24048                                }
24049                            }
24050                          else
24051                            {
24052                              if (((word >> 12) & 0x1) == 0)
24053                                {
24054                                  if (((word >> 29) & 0x1) == 0)
24055                                    {
24056                                      /* 33222222222211111111110000000000
24057                                         10987654321098765432109876543210
24058                                         xx001111xxxxxxxx0xx0x1xxxxxxxxxx
24059                                         movi.  */
24060                                      return 133;
24061                                    }
24062                                  else
24063                                    {
24064                                      /* 33222222222211111111110000000000
24065                                         10987654321098765432109876543210
24066                                         xx101111xxxxxxxx0xx0x1xxxxxxxxxx
24067                                         mvni.  */
24068                                      return 141;
24069                                    }
24070                                }
24071                              else
24072                                {
24073                                  if (((word >> 29) & 0x1) == 0)
24074                                    {
24075                                      /* 33222222222211111111110000000000
24076                                         10987654321098765432109876543210
24077                                         xx001111xxxxxxxx0xx1x1xxxxxxxxxx
24078                                         orr.  */
24079                                      return 134;
24080                                    }
24081                                  else
24082                                    {
24083                                      /* 33222222222211111111110000000000
24084                                         10987654321098765432109876543210
24085                                         xx101111xxxxxxxx0xx1x1xxxxxxxxxx
24086                                         bic.  */
24087                                      return 142;
24088                                    }
24089                                }
24090                            }
24091                        }
24092                      else
24093                        {
24094                          if (((word >> 29) & 0x1) == 0)
24095                            {
24096                              if (((word >> 30) & 0x1) == 0)
24097                                {
24098                                  if (((word >> 21) & 0x1) == 0)
24099                                    {
24100                                      /* 33222222222211111111110000000000
24101                                         10987654321098765432109876543210
24102                                         x0011111xx0xxxxx0xxxxxxxxxxxxxxx
24103                                         fmadd.  */
24104                                      return 858;
24105                                    }
24106                                  else
24107                                    {
24108                                      /* 33222222222211111111110000000000
24109                                         10987654321098765432109876543210
24110                                         x0011111xx1xxxxx0xxxxxxxxxxxxxxx
24111                                         fnmadd.  */
24112                                      return 862;
24113                                    }
24114                                }
24115                              else
24116                                {
24117                                  if (((word >> 10) & 0x1) == 0)
24118                                    {
24119                                      if (((word >> 13) & 0x1) == 0)
24120                                        {
24121                                          if (((word >> 14) & 0x1) == 0)
24122                                            {
24123                                              if (((word >> 23) & 0x1) == 0)
24124                                                {
24125                                                  /* 33222222222211111111110000000000
24126                                                     10987654321098765432109876543210
24127                                                     x10111110xxxxxxx000xx0xxxxxxxxxx
24128                                                     fmla.  */
24129                                                  return 431;
24130                                                }
24131                                              else
24132                                                {
24133                                                  /* 33222222222211111111110000000000
24134                                                     10987654321098765432109876543210
24135                                                     x10111111xxxxxxx000xx0xxxxxxxxxx
24136                                                     fmla.  */
24137                                                  return 430;
24138                                                }
24139                                            }
24140                                          else
24141                                            {
24142                                              if (((word >> 23) & 0x1) == 0)
24143                                                {
24144                                                  /* 33222222222211111111110000000000
24145                                                     10987654321098765432109876543210
24146                                                     x10111110xxxxxxx010xx0xxxxxxxxxx
24147                                                     fmls.  */
24148                                                  return 433;
24149                                                }
24150                                              else
24151                                                {
24152                                                  /* 33222222222211111111110000000000
24153                                                     10987654321098765432109876543210
24154                                                     x10111111xxxxxxx010xx0xxxxxxxxxx
24155                                                     fmls.  */
24156                                                  return 432;
24157                                                }
24158                                            }
24159                                        }
24160                                      else
24161                                        {
24162                                          if (((word >> 14) & 0x1) == 0)
24163                                            {
24164                                              /* 33222222222211111111110000000000
24165                                                 10987654321098765432109876543210
24166                                                 x1011111xxxxxxxx001xx0xxxxxxxxxx
24167                                                 sqdmlal.  */
24168                                              return 425;
24169                                            }
24170                                          else
24171                                            {
24172                                              /* 33222222222211111111110000000000
24173                                                 10987654321098765432109876543210
24174                                                 x1011111xxxxxxxx011xx0xxxxxxxxxx
24175                                                 sqdmlsl.  */
24176                                              return 426;
24177                                            }
24178                                        }
24179                                    }
24180                                  else
24181                                    {
24182                                      if (((word >> 12) & 0x1) == 0)
24183                                        {
24184                                          if (((word >> 13) & 0x1) == 0)
24185                                            {
24186                                              /* 33222222222211111111110000000000
24187                                                 10987654321098765432109876543210
24188                                                 x1011111xxxxxxxx0x00x1xxxxxxxxxx
24189                                                 sshr.  */
24190                                              return 590;
24191                                            }
24192                                          else
24193                                            {
24194                                              /* 33222222222211111111110000000000
24195                                                 10987654321098765432109876543210
24196                                                 x1011111xxxxxxxx0x10x1xxxxxxxxxx
24197                                                 srshr.  */
24198                                              return 592;
24199                                            }
24200                                        }
24201                                      else
24202                                        {
24203                                          if (((word >> 13) & 0x1) == 0)
24204                                            {
24205                                              if (((word >> 14) & 0x1) == 0)
24206                                                {
24207                                                  /* 33222222222211111111110000000000
24208                                                     10987654321098765432109876543210
24209                                                     x1011111xxxxxxxx0001x1xxxxxxxxxx
24210                                                     ssra.  */
24211                                                  return 591;
24212                                                }
24213                                              else
24214                                                {
24215                                                  /* 33222222222211111111110000000000
24216                                                     10987654321098765432109876543210
24217                                                     x1011111xxxxxxxx0101x1xxxxxxxxxx
24218                                                     shl.  */
24219                                                  return 594;
24220                                                }
24221                                            }
24222                                          else
24223                                            {
24224                                              if (((word >> 14) & 0x1) == 0)
24225                                                {
24226                                                  /* 33222222222211111111110000000000
24227                                                     10987654321098765432109876543210
24228                                                     x1011111xxxxxxxx0011x1xxxxxxxxxx
24229                                                     srsra.  */
24230                                                  return 593;
24231                                                }
24232                                              else
24233                                                {
24234                                                  /* 33222222222211111111110000000000
24235                                                     10987654321098765432109876543210
24236                                                     x1011111xxxxxxxx0111x1xxxxxxxxxx
24237                                                     sqshl.  */
24238                                                  return 595;
24239                                                }
24240                                            }
24241                                        }
24242                                    }
24243                                }
24244                            }
24245                          else
24246                            {
24247                              if (((word >> 12) & 0x1) == 0)
24248                                {
24249                                  if (((word >> 13) & 0x1) == 0)
24250                                    {
24251                                      if (((word >> 14) & 0x1) == 0)
24252                                        {
24253                                          /* 33222222222211111111110000000000
24254                                             10987654321098765432109876543210
24255                                             xx111111xxxxxxxx0000xxxxxxxxxxxx
24256                                             ushr.  */
24257                                          return 602;
24258                                        }
24259                                      else
24260                                        {
24261                                          /* 33222222222211111111110000000000
24262                                             10987654321098765432109876543210
24263                                             xx111111xxxxxxxx0100xxxxxxxxxxxx
24264                                             sri.  */
24265                                          return 606;
24266                                        }
24267                                    }
24268                                  else
24269                                    {
24270                                      if (((word >> 14) & 0x1) == 0)
24271                                        {
24272                                          /* 33222222222211111111110000000000
24273                                             10987654321098765432109876543210
24274                                             xx111111xxxxxxxx0010xxxxxxxxxxxx
24275                                             urshr.  */
24276                                          return 604;
24277                                        }
24278                                      else
24279                                        {
24280                                          /* 33222222222211111111110000000000
24281                                             10987654321098765432109876543210
24282                                             xx111111xxxxxxxx0110xxxxxxxxxxxx
24283                                             sqshlu.  */
24284                                          return 608;
24285                                        }
24286                                    }
24287                                }
24288                              else
24289                                {
24290                                  if (((word >> 13) & 0x1) == 0)
24291                                    {
24292                                      if (((word >> 14) & 0x1) == 0)
24293                                        {
24294                                          /* 33222222222211111111110000000000
24295                                             10987654321098765432109876543210
24296                                             xx111111xxxxxxxx0001xxxxxxxxxxxx
24297                                             usra.  */
24298                                          return 603;
24299                                        }
24300                                      else
24301                                        {
24302                                          /* 33222222222211111111110000000000
24303                                             10987654321098765432109876543210
24304                                             xx111111xxxxxxxx0101xxxxxxxxxxxx
24305                                             sli.  */
24306                                          return 607;
24307                                        }
24308                                    }
24309                                  else
24310                                    {
24311                                      if (((word >> 14) & 0x1) == 0)
24312                                        {
24313                                          /* 33222222222211111111110000000000
24314                                             10987654321098765432109876543210
24315                                             xx111111xxxxxxxx0011xxxxxxxxxxxx
24316                                             ursra.  */
24317                                          return 605;
24318                                        }
24319                                      else
24320                                        {
24321                                          /* 33222222222211111111110000000000
24322                                             10987654321098765432109876543210
24323                                             xx111111xxxxxxxx0111xxxxxxxxxxxx
24324                                             uqshl.  */
24325                                          return 609;
24326                                        }
24327                                    }
24328                                }
24329                            }
24330                        }
24331                    }
24332                  else
24333                    {
24334                      if (((word >> 28) & 0x1) == 0)
24335                        {
24336                          if (((word >> 10) & 0x1) == 0)
24337                            {
24338                              if (((word >> 12) & 0x1) == 0)
24339                                {
24340                                  if (((word >> 13) & 0x1) == 0)
24341                                    {
24342                                      if (((word >> 14) & 0x1) == 0)
24343                                        {
24344                                          if (((word >> 29) & 0x1) == 0)
24345                                            {
24346                                              /* 33222222222211111111110000000000
24347                                                 10987654321098765432109876543210
24348                                                 xx001111xxxxxxxx1000x0xxxxxxxxxx
24349                                                 mul.  */
24350                                              return 106;
24351                                            }
24352                                          else
24353                                            {
24354                                              if (((word >> 30) & 0x1) == 0)
24355                                                {
24356                                                  /* 33222222222211111111110000000000
24357                                                     10987654321098765432109876543210
24358                                                     x0101111xxxxxxxx1000x0xxxxxxxxxx
24359                                                     fmlal2.  */
24360                                                  return 2445;
24361                                                }
24362                                              else
24363                                                {
24364                                                  /* 33222222222211111111110000000000
24365                                                     10987654321098765432109876543210
24366                                                     x1101111xxxxxxxx1000x0xxxxxxxxxx
24367                                                     fmlal2.  */
24368                                                  return 2449;
24369                                                }
24370                                            }
24371                                        }
24372                                      else
24373                                        {
24374                                          if (((word >> 29) & 0x1) == 0)
24375                                            {
24376                                              /* 33222222222211111111110000000000
24377                                                 10987654321098765432109876543210
24378                                                 xx001111xxxxxxxx1100x0xxxxxxxxxx
24379                                                 sqdmulh.  */
24380                                              return 111;
24381                                            }
24382                                          else
24383                                            {
24384                                              if (((word >> 30) & 0x1) == 0)
24385                                                {
24386                                                  /* 33222222222211111111110000000000
24387                                                     10987654321098765432109876543210
24388                                                     x0101111xxxxxxxx1100x0xxxxxxxxxx
24389                                                     fmlsl2.  */
24390                                                  return 2446;
24391                                                }
24392                                              else
24393                                                {
24394                                                  /* 33222222222211111111110000000000
24395                                                     10987654321098765432109876543210
24396                                                     x1101111xxxxxxxx1100x0xxxxxxxxxx
24397                                                     fmlsl2.  */
24398                                                  return 2450;
24399                                                }
24400                                            }
24401                                        }
24402                                    }
24403                                  else
24404                                    {
24405                                      if (((word >> 14) & 0x1) == 0)
24406                                        {
24407                                          if (((word >> 29) & 0x1) == 0)
24408                                            {
24409                                              if (((word >> 30) & 0x1) == 0)
24410                                                {
24411                                                  /* 33222222222211111111110000000000
24412                                                     10987654321098765432109876543210
24413                                                     x0001111xxxxxxxx1010x0xxxxxxxxxx
24414                                                     smull.  */
24415                                                  return 107;
24416                                                }
24417                                              else
24418                                                {
24419                                                  /* 33222222222211111111110000000000
24420                                                     10987654321098765432109876543210
24421                                                     x1001111xxxxxxxx1010x0xxxxxxxxxx
24422                                                     smull2.  */
24423                                                  return 108;
24424                                                }
24425                                            }
24426                                          else
24427                                            {
24428                                              if (((word >> 30) & 0x1) == 0)
24429                                                {
24430                                                  /* 33222222222211111111110000000000
24431                                                     10987654321098765432109876543210
24432                                                     x0101111xxxxxxxx1010x0xxxxxxxxxx
24433                                                     umull.  */
24434                                                  return 125;
24435                                                }
24436                                              else
24437                                                {
24438                                                  /* 33222222222211111111110000000000
24439                                                     10987654321098765432109876543210
24440                                                     x1101111xxxxxxxx1010x0xxxxxxxxxx
24441                                                     umull2.  */
24442                                                  return 126;
24443                                                }
24444                                            }
24445                                        }
24446                                      else
24447                                        {
24448                                          if (((word >> 29) & 0x1) == 0)
24449                                            {
24450                                              /* 33222222222211111111110000000000
24451                                                 10987654321098765432109876543210
24452                                                 xx001111xxxxxxxx1110x0xxxxxxxxxx
24453                                                 sdot.  */
24454                                              return 2417;
24455                                            }
24456                                          else
24457                                            {
24458                                              /* 33222222222211111111110000000000
24459                                                 10987654321098765432109876543210
24460                                                 xx101111xxxxxxxx1110x0xxxxxxxxxx
24461                                                 udot.  */
24462                                              return 2416;
24463                                            }
24464                                        }
24465                                    }
24466                                }
24467                              else
24468                                {
24469                                  if (((word >> 13) & 0x1) == 0)
24470                                    {
24471                                      if (((word >> 14) & 0x1) == 0)
24472                                        {
24473                                          if (((word >> 23) & 0x1) == 0)
24474                                            {
24475                                              if (((word >> 29) & 0x1) == 0)
24476                                                {
24477                                                  /* 33222222222211111111110000000000
24478                                                     10987654321098765432109876543210
24479                                                     xx0011110xxxxxxx1001x0xxxxxxxxxx
24480                                                     fmul.  */
24481                                                  return 118;
24482                                                }
24483                                              else
24484                                                {
24485                                                  /* 33222222222211111111110000000000
24486                                                     10987654321098765432109876543210
24487                                                     xx1011110xxxxxxx1001x0xxxxxxxxxx
24488                                                     fmulx.  */
24489                                                  return 128;
24490                                                }
24491                                            }
24492                                          else
24493                                            {
24494                                              if (((word >> 29) & 0x1) == 0)
24495                                                {
24496                                                  /* 33222222222211111111110000000000
24497                                                     10987654321098765432109876543210
24498                                                     xx0011111xxxxxxx1001x0xxxxxxxxxx
24499                                                     fmul.  */
24500                                                  return 117;
24501                                                }
24502                                              else
24503                                                {
24504                                                  /* 33222222222211111111110000000000
24505                                                     10987654321098765432109876543210
24506                                                     xx1011111xxxxxxx1001x0xxxxxxxxxx
24507                                                     fmulx.  */
24508                                                  return 127;
24509                                                }
24510                                            }
24511                                        }
24512                                      else
24513                                        {
24514                                          if (((word >> 29) & 0x1) == 0)
24515                                            {
24516                                              /* 33222222222211111111110000000000
24517                                                 10987654321098765432109876543210
24518                                                 xx001111xxxxxxxx1101x0xxxxxxxxxx
24519                                                 sqrdmulh.  */
24520                                              return 112;
24521                                            }
24522                                          else
24523                                            {
24524                                              /* 33222222222211111111110000000000
24525                                                 10987654321098765432109876543210
24526                                                 xx101111xxxxxxxx1101x0xxxxxxxxxx
24527                                                 sqrdmlah.  */
24528                                              return 129;
24529                                            }
24530                                        }
24531                                    }
24532                                  else
24533                                    {
24534                                      if (((word >> 14) & 0x1) == 0)
24535                                        {
24536                                          if (((word >> 30) & 0x1) == 0)
24537                                            {
24538                                              /* 33222222222211111111110000000000
24539                                                 10987654321098765432109876543210
24540                                                 x0x01111xxxxxxxx1011x0xxxxxxxxxx
24541                                                 sqdmull.  */
24542                                              return 109;
24543                                            }
24544                                          else
24545                                            {
24546                                              /* 33222222222211111111110000000000
24547                                                 10987654321098765432109876543210
24548                                                 x1x01111xxxxxxxx1011x0xxxxxxxxxx
24549                                                 sqdmull2.  */
24550                                              return 110;
24551                                            }
24552                                        }
24553                                      else
24554                                        {
24555                                          if (((word >> 29) & 0x1) == 0)
24556                                            {
24557                                              if (((word >> 22) & 0x1) == 0)
24558                                                {
24559                                                  if (((word >> 23) & 0x1) == 0)
24560                                                    {
24561                                                      /* 33222222222211111111110000000000
24562                                                         10987654321098765432109876543210
24563                                                         xx00111100xxxxxx1111x0xxxxxxxxxx
24564                                                         sudot.  */
24565                                                      return 2494;
24566                                                    }
24567                                                  else
24568                                                    {
24569                                                      /* 33222222222211111111110000000000
24570                                                         10987654321098765432109876543210
24571                                                         xx00111110xxxxxx1111x0xxxxxxxxxx
24572                                                         usdot.  */
24573                                                      return 2493;
24574                                                    }
24575                                                }
24576                                              else
24577                                                {
24578                                                  if (((word >> 23) & 0x1) == 0)
24579                                                    {
24580                                                      /* 33222222222211111111110000000000
24581                                                         10987654321098765432109876543210
24582                                                         xx00111101xxxxxx1111x0xxxxxxxxxx
24583                                                         bfdot.  */
24584                                                      return 2505;
24585                                                    }
24586                                                  else
24587                                                    {
24588                                                      if (((word >> 30) & 0x1) == 0)
24589                                                        {
24590                                                          /* 33222222222211111111110000000000
24591                                                             10987654321098765432109876543210
24592                                                             x000111111xxxxxx1111x0xxxxxxxxxx
24593                                                             bfmlalb.  */
24594                                                          return 2513;
24595                                                        }
24596                                                      else
24597                                                        {
24598                                                          /* 33222222222211111111110000000000
24599                                                             10987654321098765432109876543210
24600                                                             x100111111xxxxxx1111x0xxxxxxxxxx
24601                                                             bfmlalt.  */
24602                                                          return 2512;
24603                                                        }
24604                                                    }
24605                                                }
24606                                            }
24607                                          else
24608                                            {
24609                                              /* 33222222222211111111110000000000
24610                                                 10987654321098765432109876543210
24611                                                 xx101111xxxxxxxx1111x0xxxxxxxxxx
24612                                                 sqrdmlsh.  */
24613                                              return 130;
24614                                            }
24615                                        }
24616                                    }
24617                                }
24618                            }
24619                          else
24620                            {
24621                              if (((word >> 11) & 0x1) == 0)
24622                                {
24623                                  if (((word >> 14) & 0x1) == 0)
24624                                    {
24625                                      if (((word >> 12) & 0x1) == 0)
24626                                        {
24627                                          if (((word >> 29) & 0x1) == 0)
24628                                            {
24629                                              /* 33222222222211111111110000000000
24630                                                 10987654321098765432109876543210
24631                                                 xx001111xxxxxxxx10x001xxxxxxxxxx
24632                                                 movi.  */
24633                                              return 135;
24634                                            }
24635                                          else
24636                                            {
24637                                              /* 33222222222211111111110000000000
24638                                                 10987654321098765432109876543210
24639                                                 xx101111xxxxxxxx10x001xxxxxxxxxx
24640                                                 mvni.  */
24641                                              return 143;
24642                                            }
24643                                        }
24644                                      else
24645                                        {
24646                                          if (((word >> 29) & 0x1) == 0)
24647                                            {
24648                                              /* 33222222222211111111110000000000
24649                                                 10987654321098765432109876543210
24650                                                 xx001111xxxxxxxx10x101xxxxxxxxxx
24651                                                 orr.  */
24652                                              return 136;
24653                                            }
24654                                          else
24655                                            {
24656                                              /* 33222222222211111111110000000000
24657                                                 10987654321098765432109876543210
24658                                                 xx101111xxxxxxxx10x101xxxxxxxxxx
24659                                                 bic.  */
24660                                              return 144;
24661                                            }
24662                                        }
24663                                    }
24664                                  else
24665                                    {
24666                                      if (((word >> 13) & 0x1) == 0)
24667                                        {
24668                                          if (((word >> 29) & 0x1) == 0)
24669                                            {
24670                                              /* 33222222222211111111110000000000
24671                                                 10987654321098765432109876543210
24672                                                 xx001111xxxxxxxx110x01xxxxxxxxxx
24673                                                 movi.  */
24674                                              return 137;
24675                                            }
24676                                          else
24677                                            {
24678                                              /* 33222222222211111111110000000000
24679                                                 10987654321098765432109876543210
24680                                                 xx101111xxxxxxxx110x01xxxxxxxxxx
24681                                                 mvni.  */
24682                                              return 145;
24683                                            }
24684                                        }
24685                                      else
24686                                        {
24687                                          if (((word >> 12) & 0x1) == 0)
24688                                            {
24689                                              if (((word >> 29) & 0x1) == 0)
24690                                                {
24691                                                  /* 33222222222211111111110000000000
24692                                                     10987654321098765432109876543210
24693                                                     xx001111xxxxxxxx111001xxxxxxxxxx
24694                                                     movi.  */
24695                                                  return 138;
24696                                                }
24697                                              else
24698                                                {
24699                                                  /* 33222222222211111111110000000000
24700                                                     10987654321098765432109876543210
24701                                                     xx101111xxxxxxxx111001xxxxxxxxxx
24702                                                     movi.  */
24703                                                  return 146;
24704                                                }
24705                                            }
24706                                          else
24707                                            {
24708                                              if (((word >> 29) & 0x1) == 0)
24709                                                {
24710                                                  /* 33222222222211111111110000000000
24711                                                     10987654321098765432109876543210
24712                                                     xx001111xxxxxxxx111101xxxxxxxxxx
24713                                                     fmov.  */
24714                                                  return 139;
24715                                                }
24716                                              else
24717                                                {
24718                                                  /* 33222222222211111111110000000000
24719                                                     10987654321098765432109876543210
24720                                                     xx101111xxxxxxxx111101xxxxxxxxxx
24721                                                     fmov.  */
24722                                                  return 148;
24723                                                }
24724                                            }
24725                                        }
24726                                    }
24727                                }
24728                              else
24729                                {
24730                                  if (((word >> 12) & 0x1) == 0)
24731                                    {
24732                                      if (((word >> 29) & 0x1) == 0)
24733                                        {
24734                                          if (((word >> 30) & 0x1) == 0)
24735                                            {
24736                                              /* 33222222222211111111110000000000
24737                                                 10987654321098765432109876543210
24738                                                 x0001111xxxxxxxx1xx011xxxxxxxxxx
24739                                                 rshrn.  */
24740                                              return 382;
24741                                            }
24742                                          else
24743                                            {
24744                                              /* 33222222222211111111110000000000
24745                                                 10987654321098765432109876543210
24746                                                 x1001111xxxxxxxx1xx011xxxxxxxxxx
24747                                                 rshrn2.  */
24748                                              return 383;
24749                                            }
24750                                        }
24751                                      else
24752                                        {
24753                                          if (((word >> 30) & 0x1) == 0)
24754                                            {
24755                                              /* 33222222222211111111110000000000
24756                                                 10987654321098765432109876543210
24757                                                 x0101111xxxxxxxx1xx011xxxxxxxxxx
24758                                                 sqrshrun.  */
24759                                              return 406;
24760                                            }
24761                                          else
24762                                            {
24763                                              /* 33222222222211111111110000000000
24764                                                 10987654321098765432109876543210
24765                                                 x1101111xxxxxxxx1xx011xxxxxxxxxx
24766                                                 sqrshrun2.  */
24767                                              return 407;
24768                                            }
24769                                        }
24770                                    }
24771                                  else
24772                                    {
24773                                      if (((word >> 13) & 0x1) == 0)
24774                                        {
24775                                          if (((word >> 29) & 0x1) == 0)
24776                                            {
24777                                              if (((word >> 30) & 0x1) == 0)
24778                                                {
24779                                                  /* 33222222222211111111110000000000
24780                                                     10987654321098765432109876543210
24781                                                     x0001111xxxxxxxx1x0111xxxxxxxxxx
24782                                                     sqrshrn.  */
24783                                                  return 386;
24784                                                }
24785                                              else
24786                                                {
24787                                                  /* 33222222222211111111110000000000
24788                                                     10987654321098765432109876543210
24789                                                     x1001111xxxxxxxx1x0111xxxxxxxxxx
24790                                                     sqrshrn2.  */
24791                                                  return 387;
24792                                                }
24793                                            }
24794                                          else
24795                                            {
24796                                              if (((word >> 30) & 0x1) == 0)
24797                                                {
24798                                                  /* 33222222222211111111110000000000
24799                                                     10987654321098765432109876543210
24800                                                     x0101111xxxxxxxx1x0111xxxxxxxxxx
24801                                                     uqrshrn.  */
24802                                                  return 410;
24803                                                }
24804                                              else
24805                                                {
24806                                                  /* 33222222222211111111110000000000
24807                                                     10987654321098765432109876543210
24808                                                     x1101111xxxxxxxx1x0111xxxxxxxxxx
24809                                                     uqrshrn2.  */
24810                                                  return 411;
24811                                                }
24812                                            }
24813                                        }
24814                                      else
24815                                        {
24816                                          if (((word >> 29) & 0x1) == 0)
24817                                            {
24818                                              /* 33222222222211111111110000000000
24819                                                 10987654321098765432109876543210
24820                                                 xx001111xxxxxxxx1x1111xxxxxxxxxx
24821                                                 fmov.  */
24822                                              return 140;
24823                                            }
24824                                          else
24825                                            {
24826                                              /* 33222222222211111111110000000000
24827                                                 10987654321098765432109876543210
24828                                                 xx101111xxxxxxxx1x1111xxxxxxxxxx
24829                                                 fcvtzu.  */
24830                                              return 418;
24831                                            }
24832                                        }
24833                                    }
24834                                }
24835                            }
24836                        }
24837                      else
24838                        {
24839                          if (((word >> 29) & 0x1) == 0)
24840                            {
24841                              if (((word >> 30) & 0x1) == 0)
24842                                {
24843                                  if (((word >> 21) & 0x1) == 0)
24844                                    {
24845                                      /* 33222222222211111111110000000000
24846                                         10987654321098765432109876543210
24847                                         x0011111xx0xxxxx1xxxxxxxxxxxxxxx
24848                                         fmsub.  */
24849                                      return 860;
24850                                    }
24851                                  else
24852                                    {
24853                                      /* 33222222222211111111110000000000
24854                                         10987654321098765432109876543210
24855                                         x0011111xx1xxxxx1xxxxxxxxxxxxxxx
24856                                         fnmsub.  */
24857                                      return 864;
24858                                    }
24859                                }
24860                              else
24861                                {
24862                                  if (((word >> 10) & 0x1) == 0)
24863                                    {
24864                                      if (((word >> 12) & 0x1) == 0)
24865                                        {
24866                                          /* 33222222222211111111110000000000
24867                                             10987654321098765432109876543210
24868                                             x1011111xxxxxxxx1xx0x0xxxxxxxxxx
24869                                             sqdmulh.  */
24870                                          return 428;
24871                                        }
24872                                      else
24873                                        {
24874                                          if (((word >> 13) & 0x1) == 0)
24875                                            {
24876                                              if (((word >> 14) & 0x1) == 0)
24877                                                {
24878                                                  if (((word >> 23) & 0x1) == 0)
24879                                                    {
24880                                                      /* 33222222222211111111110000000000
24881                                                         10987654321098765432109876543210
24882                                                         x10111110xxxxxxx1001x0xxxxxxxxxx
24883                                                         fmul.  */
24884                                                      return 435;
24885                                                    }
24886                                                  else
24887                                                    {
24888                                                      /* 33222222222211111111110000000000
24889                                                         10987654321098765432109876543210
24890                                                         x10111111xxxxxxx1001x0xxxxxxxxxx
24891                                                         fmul.  */
24892                                                      return 434;
24893                                                    }
24894                                                }
24895                                              else
24896                                                {
24897                                                  /* 33222222222211111111110000000000
24898                                                     10987654321098765432109876543210
24899                                                     x1011111xxxxxxxx1101x0xxxxxxxxxx
24900                                                     sqrdmulh.  */
24901                                                  return 429;
24902                                                }
24903                                            }
24904                                          else
24905                                            {
24906                                              /* 33222222222211111111110000000000
24907                                                 10987654321098765432109876543210
24908                                                 x1011111xxxxxxxx1x11x0xxxxxxxxxx
24909                                                 sqdmull.  */
24910                                              return 427;
24911                                            }
24912                                        }
24913                                    }
24914                                  else
24915                                    {
24916                                      if (((word >> 11) & 0x1) == 0)
24917                                        {
24918                                          if (((word >> 12) & 0x1) == 0)
24919                                            {
24920                                              /* 33222222222211111111110000000000
24921                                                 10987654321098765432109876543210
24922                                                 x1011111xxxxxxxx1xx001xxxxxxxxxx
24923                                                 scvtf.  */
24924                                              return 598;
24925                                            }
24926                                          else
24927                                            {
24928                                              /* 33222222222211111111110000000000
24929                                                 10987654321098765432109876543210
24930                                                 x1011111xxxxxxxx1xx101xxxxxxxxxx
24931                                                 sqshrn.  */
24932                                              return 596;
24933                                            }
24934                                        }
24935                                      else
24936                                        {
24937                                          if (((word >> 13) & 0x1) == 0)
24938                                            {
24939                                              /* 33222222222211111111110000000000
24940                                                 10987654321098765432109876543210
24941                                                 x1011111xxxxxxxx1x0x11xxxxxxxxxx
24942                                                 sqrshrn.  */
24943                                              return 597;
24944                                            }
24945                                          else
24946                                            {
24947                                              /* 33222222222211111111110000000000
24948                                                 10987654321098765432109876543210
24949                                                 x1011111xxxxxxxx1x1x11xxxxxxxxxx
24950                                                 fcvtzs.  */
24951                                              return 600;
24952                                            }
24953                                        }
24954                                    }
24955                                }
24956                            }
24957                          else
24958                            {
24959                              if (((word >> 10) & 0x1) == 0)
24960                                {
24961                                  if (((word >> 13) & 0x1) == 0)
24962                                    {
24963                                      if (((word >> 14) & 0x1) == 0)
24964                                        {
24965                                          if (((word >> 23) & 0x1) == 0)
24966                                            {
24967                                              /* 33222222222211111111110000000000
24968                                                 10987654321098765432109876543210
24969                                                 xx1111110xxxxxxx100xx0xxxxxxxxxx
24970                                                 fmulx.  */
24971                                              return 437;
24972                                            }
24973                                          else
24974                                            {
24975                                              /* 33222222222211111111110000000000
24976                                                 10987654321098765432109876543210
24977                                                 xx1111111xxxxxxx100xx0xxxxxxxxxx
24978                                                 fmulx.  */
24979                                              return 436;
24980                                            }
24981                                        }
24982                                      else
24983                                        {
24984                                          /* 33222222222211111111110000000000
24985                                             10987654321098765432109876543210
24986                                             xx111111xxxxxxxx110xx0xxxxxxxxxx
24987                                             sqrdmlah.  */
24988                                          return 438;
24989                                        }
24990                                    }
24991                                  else
24992                                    {
24993                                      /* 33222222222211111111110000000000
24994                                         10987654321098765432109876543210
24995                                         xx111111xxxxxxxx1x1xx0xxxxxxxxxx
24996                                         sqrdmlsh.  */
24997                                      return 439;
24998                                    }
24999                                }
25000                              else
25001                                {
25002                                  if (((word >> 11) & 0x1) == 0)
25003                                    {
25004                                      if (((word >> 12) & 0x1) == 0)
25005                                        {
25006                                          if (((word >> 13) & 0x1) == 0)
25007                                            {
25008                                              /* 33222222222211111111110000000000
25009                                                 10987654321098765432109876543210
25010                                                 xx111111xxxxxxxx1x0001xxxxxxxxxx
25011                                                 sqshrun.  */
25012                                              return 610;
25013                                            }
25014                                          else
25015                                            {
25016                                              /* 33222222222211111111110000000000
25017                                                 10987654321098765432109876543210
25018                                                 xx111111xxxxxxxx1x1001xxxxxxxxxx
25019                                                 ucvtf.  */
25020                                              return 614;
25021                                            }
25022                                        }
25023                                      else
25024                                        {
25025                                          /* 33222222222211111111110000000000
25026                                             10987654321098765432109876543210
25027                                             xx111111xxxxxxxx1xx101xxxxxxxxxx
25028                                             uqshrn.  */
25029                                          return 612;
25030                                        }
25031                                    }
25032                                  else
25033                                    {
25034                                      if (((word >> 12) & 0x1) == 0)
25035                                        {
25036                                          /* 33222222222211111111110000000000
25037                                             10987654321098765432109876543210
25038                                             xx111111xxxxxxxx1xx011xxxxxxxxxx
25039                                             sqrshrun.  */
25040                                          return 611;
25041                                        }
25042                                      else
25043                                        {
25044                                          if (((word >> 13) & 0x1) == 0)
25045                                            {
25046                                              /* 33222222222211111111110000000000
25047                                                 10987654321098765432109876543210
25048                                                 xx111111xxxxxxxx1x0111xxxxxxxxxx
25049                                                 uqrshrn.  */
25050                                              return 613;
25051                                            }
25052                                          else
25053                                            {
25054                                              /* 33222222222211111111110000000000
25055                                                 10987654321098765432109876543210
25056                                                 xx111111xxxxxxxx1x1111xxxxxxxxxx
25057                                                 fcvtzu.  */
25058                                              return 616;
25059                                            }
25060                                        }
25061                                    }
25062                                }
25063                            }
25064                        }
25065                    }
25066                }
25067            }
25068        }
25069    }
25070}
25071
25072/* Lookup opcode WORD in the opcode table.  N.B. all alias
25073   opcodes are ignored here.  */
25074
25075const aarch64_opcode *
25076aarch64_opcode_lookup (uint32_t word)
25077{
25078  return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
25079}
25080
25081const aarch64_opcode *
25082aarch64_find_next_opcode (const aarch64_opcode *opcode)
25083{
25084  /* Use the index as the key to locate the next opcode.  */
25085  int key = opcode - aarch64_opcode_table;
25086  int value;
25087  switch (key)
25088    {
25089    case 2384: value = 2386; break;	/* mov --> mova.  */
25090    case 2386: return NULL;		/* mova --> NULL.  */
25091    case 2383: value = 2385; break;	/* mov --> mova.  */
25092    case 2385: return NULL;		/* mova --> NULL.  */
25093    case 2388: value = 2393; break;	/* ld1b --> ld1b.  */
25094    case 2393: return NULL;		/* ld1b --> NULL.  */
25095    case 2390: value = 2395; break;	/* ld1w --> ld1w.  */
25096    case 2395: return NULL;		/* ld1w --> NULL.  */
25097    case 2389: value = 2394; break;	/* ld1h --> ld1h.  */
25098    case 2394: return NULL;		/* ld1h --> NULL.  */
25099    case 2391: value = 2396; break;	/* ld1d --> ld1d.  */
25100    case 2396: return NULL;		/* ld1d --> NULL.  */
25101    case 2398: value = 2403; break;	/* st1b --> st1b.  */
25102    case 2403: return NULL;		/* st1b --> NULL.  */
25103    case 2400: value = 2405; break;	/* st1w --> st1w.  */
25104    case 2405: return NULL;		/* st1w --> NULL.  */
25105    case 2399: value = 2404; break;	/* st1h --> st1h.  */
25106    case 2404: return NULL;		/* st1h --> NULL.  */
25107    case 2401: value = 2406; break;	/* st1d --> st1d.  */
25108    case 2406: return NULL;		/* st1d --> NULL.  */
25109    case 2392: value = 2397; break;	/* ld1q --> ld1q.  */
25110    case 2397: return NULL;		/* ld1q --> NULL.  */
25111    case 2402: value = 2407; break;	/* st1q --> st1q.  */
25112    case 2407: return NULL;		/* st1q --> NULL.  */
25113    case 12: value = 19; break;	/* add --> addg.  */
25114    case 19: return NULL;		/* addg --> NULL.  */
25115    case 16: value = 20; break;	/* sub --> subg.  */
25116    case 20: return NULL;		/* subg --> NULL.  */
25117    case 971: value = 975; break;	/* stnp --> stp.  */
25118    case 975: return NULL;		/* stp --> NULL.  */
25119    case 969: value = 970; break;	/* stllrb --> stllrh.  */
25120    case 970: return NULL;		/* stllrh --> NULL.  */
25121    case 972: value = 976; break;	/* ldnp --> ldp.  */
25122    case 976: return NULL;		/* ldp --> NULL.  */
25123    case 1640: value = 1641; break;	/* ldff1b --> ldff1b.  */
25124    case 1641: return NULL;		/* ldff1b --> NULL.  */
25125    case 1696: value = 1697; break;	/* ldff1sw --> ldff1sw.  */
25126    case 1697: return NULL;		/* ldff1sw --> NULL.  */
25127    case 1644: value = 1645; break;	/* ldff1b --> ldff1b.  */
25128    case 1645: return NULL;		/* ldff1b --> NULL.  */
25129    case 1663: value = 1664; break;	/* ldff1h --> ldff1h.  */
25130    case 1664: return NULL;		/* ldff1h --> NULL.  */
25131    case 1642: value = 1643; break;	/* ldff1b --> ldff1b.  */
25132    case 1643: return NULL;		/* ldff1b --> NULL.  */
25133    case 1661: value = 1662; break;	/* ldff1h --> ldff1h.  */
25134    case 1662: return NULL;		/* ldff1h --> NULL.  */
25135    case 1646: value = 1647; break;	/* ldff1b --> ldff1b.  */
25136    case 1647: return NULL;		/* ldff1b --> NULL.  */
25137    case 1665: value = 1666; break;	/* ldff1h --> ldff1h.  */
25138    case 1666: return NULL;		/* ldff1h --> NULL.  */
25139    case 1686: value = 1687; break;	/* ldff1sh --> ldff1sh.  */
25140    case 1687: return NULL;		/* ldff1sh --> NULL.  */
25141    case 1674: value = 1675; break;	/* ldff1sb --> ldff1sb.  */
25142    case 1675: return NULL;		/* ldff1sb --> NULL.  */
25143    case 1705: value = 1706; break;	/* ldff1w --> ldff1w.  */
25144    case 1706: return NULL;		/* ldff1w --> NULL.  */
25145    case 1678: value = 1679; break;	/* ldff1sb --> ldff1sb.  */
25146    case 1679: return NULL;		/* ldff1sb --> NULL.  */
25147    case 1688: value = 1689; break;	/* ldff1sh --> ldff1sh.  */
25148    case 1689: return NULL;		/* ldff1sh --> NULL.  */
25149    case 1676: value = 1677; break;	/* ldff1sb --> ldff1sb.  */
25150    case 1677: return NULL;		/* ldff1sb --> NULL.  */
25151    case 1707: value = 1708; break;	/* ldff1w --> ldff1w.  */
25152    case 1708: return NULL;		/* ldff1w --> NULL.  */
25153    case 1652: value = 1653; break;	/* ldff1d --> ldff1d.  */
25154    case 1653: return NULL;		/* ldff1d --> NULL.  */
25155    case 811: value = 812; break;	/* xaflag --> axflag.  */
25156    case 812: value = 1194; break;	/* axflag --> tcommit.  */
25157    case 1194: value = 1197; break;	/* tcommit --> smstart.  */
25158    case 1197: value = 1198; break;	/* smstart --> smstop.  */
25159    case 1198: value = 1199; break;	/* smstop --> smstart.  */
25160    case 1199: value = 1200; break;	/* smstart --> smstop.  */
25161    case 1200: value = 1201; break;	/* smstop --> msr.  */
25162    case 1201: value = 1202; break;	/* msr --> hint.  */
25163    case 1202: value = 1211; break;	/* hint --> dgh.  */
25164    case 1211: value = 1220; break;	/* dgh --> clrex.  */
25165    case 1220: value = 1221; break;	/* clrex --> dsb.  */
25166    case 1221: value = 1222; break;	/* dsb --> dsb.  */
25167    case 1222: value = 1226; break;	/* dsb --> dmb.  */
25168    case 1226: value = 1227; break;	/* dmb --> isb.  */
25169    case 1227: value = 1228; break;	/* isb --> sb.  */
25170    case 1228: value = 1229; break;	/* sb --> sys.  */
25171    case 1229: value = 1234; break;	/* sys --> wfet.  */
25172    case 1234: value = 1235; break;	/* wfet --> wfit.  */
25173    case 1235: value = 1239; break;	/* wfit --> cfinv.  */
25174    case 1239: value = 1240; break;	/* cfinv --> msr.  */
25175    case 1240: return NULL;		/* msr --> NULL.  */
25176    case 1193: value = 1195; break;	/* tstart --> ttest.  */
25177    case 1195: value = 1241; break;	/* ttest --> sysl.  */
25178    case 1241: value = 1242; break;	/* sysl --> mrs.  */
25179    case 1242: return NULL;		/* mrs --> NULL.  */
25180    case 440: value = 441; break;	/* st4 --> st1.  */
25181    case 441: value = 442; break;	/* st1 --> st2.  */
25182    case 442: value = 443; break;	/* st2 --> st3.  */
25183    case 443: return NULL;		/* st3 --> NULL.  */
25184    case 448: value = 449; break;	/* st4 --> st1.  */
25185    case 449: value = 450; break;	/* st1 --> st2.  */
25186    case 450: value = 451; break;	/* st2 --> st3.  */
25187    case 451: return NULL;		/* st3 --> NULL.  */
25188    case 444: value = 445; break;	/* ld4 --> ld1.  */
25189    case 445: value = 446; break;	/* ld1 --> ld2.  */
25190    case 446: value = 447; break;	/* ld2 --> ld3.  */
25191    case 447: return NULL;		/* ld3 --> NULL.  */
25192    case 460: value = 462; break;	/* ld1 --> ld1r.  */
25193    case 462: return NULL;		/* ld1r --> NULL.  */
25194    case 464: value = 466; break;	/* ld2 --> ld2r.  */
25195    case 466: return NULL;		/* ld2r --> NULL.  */
25196    case 461: value = 463; break;	/* ld3 --> ld3r.  */
25197    case 463: return NULL;		/* ld3r --> NULL.  */
25198    case 465: value = 467; break;	/* ld4 --> ld4r.  */
25199    case 467: return NULL;		/* ld4r --> NULL.  */
25200    case 452: value = 453; break;	/* ld4 --> ld1.  */
25201    case 453: value = 454; break;	/* ld1 --> ld2.  */
25202    case 454: value = 455; break;	/* ld2 --> ld3.  */
25203    case 455: return NULL;		/* ld3 --> NULL.  */
25204    case 472: value = 474; break;	/* ld1 --> ld1r.  */
25205    case 474: return NULL;		/* ld1r --> NULL.  */
25206    case 473: value = 475; break;	/* ld3 --> ld3r.  */
25207    case 475: return NULL;		/* ld3r --> NULL.  */
25208    case 476: value = 478; break;	/* ld2 --> ld2r.  */
25209    case 478: return NULL;		/* ld2r --> NULL.  */
25210    case 477: value = 479; break;	/* ld4 --> ld4r.  */
25211    case 479: return NULL;		/* ld4r --> NULL.  */
25212    case 764: value = 765; break;	/* fcvtzs --> fcvtzs.  */
25213    case 765: return NULL;		/* fcvtzs --> NULL.  */
25214    case 760: value = 761; break;	/* scvtf --> scvtf.  */
25215    case 761: return NULL;		/* scvtf --> NULL.  */
25216    case 766: value = 767; break;	/* fcvtzu --> fcvtzu.  */
25217    case 767: return NULL;		/* fcvtzu --> NULL.  */
25218    case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
25219    case 763: return NULL;		/* ucvtf --> NULL.  */
25220    case 768: value = 769; break;	/* fcvtns --> fcvtns.  */
25221    case 769: return NULL;		/* fcvtns --> NULL.  */
25222    case 788: value = 789; break;	/* fcvtms --> fcvtms.  */
25223    case 789: return NULL;		/* fcvtms --> NULL.  */
25224    case 784: value = 785; break;	/* fcvtps --> fcvtps.  */
25225    case 785: return NULL;		/* fcvtps --> NULL.  */
25226    case 792: value = 793; break;	/* fcvtzs --> fcvtzs.  */
25227    case 793: return NULL;		/* fcvtzs --> NULL.  */
25228    case 776: value = 777; break;	/* fcvtas --> fcvtas.  */
25229    case 777: return NULL;		/* fcvtas --> NULL.  */
25230    case 772: value = 773; break;	/* scvtf --> scvtf.  */
25231    case 773: return NULL;		/* scvtf --> NULL.  */
25232    case 780: value = 781; break;	/* fmov --> fmov.  */
25233    case 781: return NULL;		/* fmov --> NULL.  */
25234    case 770: value = 771; break;	/* fcvtnu --> fcvtnu.  */
25235    case 771: return NULL;		/* fcvtnu --> NULL.  */
25236    case 790: value = 791; break;	/* fcvtmu --> fcvtmu.  */
25237    case 791: return NULL;		/* fcvtmu --> NULL.  */
25238    case 786: value = 787; break;	/* fcvtpu --> fcvtpu.  */
25239    case 787: return NULL;		/* fcvtpu --> NULL.  */
25240    case 794: value = 795; break;	/* fcvtzu --> fcvtzu.  */
25241    case 795: return NULL;		/* fcvtzu --> NULL.  */
25242    case 778: value = 779; break;	/* fcvtau --> fcvtau.  */
25243    case 779: return NULL;		/* fcvtau --> NULL.  */
25244    case 774: value = 775; break;	/* ucvtf --> ucvtf.  */
25245    case 775: return NULL;		/* ucvtf --> NULL.  */
25246    case 782: value = 783; break;	/* fmov --> fmov.  */
25247    case 783: return NULL;		/* fmov --> NULL.  */
25248    case 817: value = 818; break;	/* fmov --> fmov.  */
25249    case 818: return NULL;		/* fmov --> NULL.  */
25250    case 826: value = 827; break;	/* frintn --> frintn.  */
25251    case 827: return NULL;		/* frintn --> NULL.  */
25252    case 821: value = 822; break;	/* fneg --> fneg.  */
25253    case 822: return NULL;		/* fneg --> NULL.  */
25254    case 830: value = 831; break;	/* frintm --> frintm.  */
25255    case 831: return NULL;		/* frintm --> NULL.  */
25256    case 819: value = 820; break;	/* fabs --> fabs.  */
25257    case 820: return NULL;		/* fabs --> NULL.  */
25258    case 828: value = 829; break;	/* frintp --> frintp.  */
25259    case 829: return NULL;		/* frintp --> NULL.  */
25260    case 823: value = 824; break;	/* fsqrt --> fsqrt.  */
25261    case 824: return NULL;		/* fsqrt --> NULL.  */
25262    case 832: value = 833; break;	/* frintz --> frintz.  */
25263    case 833: return NULL;		/* frintz --> NULL.  */
25264    case 825: value = 2509; break;	/* fcvt --> bfcvt.  */
25265    case 2509: return NULL;		/* bfcvt --> NULL.  */
25266    case 834: value = 835; break;	/* frinta --> frinta.  */
25267    case 835: return NULL;		/* frinta --> NULL.  */
25268    case 836: value = 837; break;	/* frintx --> frintx.  */
25269    case 837: return NULL;		/* frintx --> NULL.  */
25270    case 838: value = 839; break;	/* frinti --> frinti.  */
25271    case 839: return NULL;		/* frinti --> NULL.  */
25272    case 803: value = 804; break;	/* fcmp --> fcmp.  */
25273    case 804: return NULL;		/* fcmp --> NULL.  */
25274    case 805: value = 806; break;	/* fcmpe --> fcmpe.  */
25275    case 806: return NULL;		/* fcmpe --> NULL.  */
25276    case 807: value = 808; break;	/* fcmp --> fcmp.  */
25277    case 808: return NULL;		/* fcmp --> NULL.  */
25278    case 809: value = 810; break;	/* fcmpe --> fcmpe.  */
25279    case 810: return NULL;		/* fcmpe --> NULL.  */
25280    case 866: value = 867; break;	/* fmov --> fmov.  */
25281    case 867: return NULL;		/* fmov --> NULL.  */
25282    case 840: value = 841; break;	/* fmul --> fmul.  */
25283    case 841: return NULL;		/* fmul --> NULL.  */
25284    case 856: value = 857; break;	/* fnmul --> fnmul.  */
25285    case 857: return NULL;		/* fnmul --> NULL.  */
25286    case 848: value = 849; break;	/* fmax --> fmax.  */
25287    case 849: return NULL;		/* fmax --> NULL.  */
25288    case 844: value = 845; break;	/* fadd --> fadd.  */
25289    case 845: return NULL;		/* fadd --> NULL.  */
25290    case 852: value = 853; break;	/* fmaxnm --> fmaxnm.  */
25291    case 853: return NULL;		/* fmaxnm --> NULL.  */
25292    case 842: value = 843; break;	/* fdiv --> fdiv.  */
25293    case 843: return NULL;		/* fdiv --> NULL.  */
25294    case 850: value = 851; break;	/* fmin --> fmin.  */
25295    case 851: return NULL;		/* fmin --> NULL.  */
25296    case 846: value = 847; break;	/* fsub --> fsub.  */
25297    case 847: return NULL;		/* fsub --> NULL.  */
25298    case 854: value = 855; break;	/* fminnm --> fminnm.  */
25299    case 855: return NULL;		/* fminnm --> NULL.  */
25300    case 799: value = 800; break;	/* fccmp --> fccmp.  */
25301    case 800: return NULL;		/* fccmp --> NULL.  */
25302    case 801: value = 802; break;	/* fccmpe --> fccmpe.  */
25303    case 802: return NULL;		/* fccmpe --> NULL.  */
25304    case 868: value = 869; break;	/* fcsel --> fcsel.  */
25305    case 869: return NULL;		/* fcsel --> NULL.  */
25306    case 133: value = 374; break;	/* movi --> sshr.  */
25307    case 374: value = 376; break;	/* sshr --> srshr.  */
25308    case 376: return NULL;		/* srshr --> NULL.  */
25309    case 141: value = 396; break;	/* mvni --> ushr.  */
25310    case 396: value = 398; break;	/* ushr --> urshr.  */
25311    case 398: value = 400; break;	/* urshr --> sri.  */
25312    case 400: value = 402; break;	/* sri --> sqshlu.  */
25313    case 402: return NULL;		/* sqshlu --> NULL.  */
25314    case 134: value = 375; break;	/* orr --> ssra.  */
25315    case 375: value = 377; break;	/* ssra --> srsra.  */
25316    case 377: value = 378; break;	/* srsra --> shl.  */
25317    case 378: value = 379; break;	/* shl --> sqshl.  */
25318    case 379: return NULL;		/* sqshl --> NULL.  */
25319    case 142: value = 397; break;	/* bic --> usra.  */
25320    case 397: value = 399; break;	/* usra --> ursra.  */
25321    case 399: value = 401; break;	/* ursra --> sli.  */
25322    case 401: value = 403; break;	/* sli --> uqshl.  */
25323    case 403: return NULL;		/* uqshl --> NULL.  */
25324    case 858: value = 859; break;	/* fmadd --> fmadd.  */
25325    case 859: return NULL;		/* fmadd --> NULL.  */
25326    case 862: value = 863; break;	/* fnmadd --> fnmadd.  */
25327    case 863: return NULL;		/* fnmadd --> NULL.  */
25328    case 135: value = 380; break;	/* movi --> shrn.  */
25329    case 380: value = 381; break;	/* shrn --> shrn2.  */
25330    case 381: value = 388; break;	/* shrn2 --> sshll.  */
25331    case 388: value = 390; break;	/* sshll --> sshll2.  */
25332    case 390: return NULL;		/* sshll2 --> NULL.  */
25333    case 143: value = 404; break;	/* mvni --> sqshrun.  */
25334    case 404: value = 405; break;	/* sqshrun --> sqshrun2.  */
25335    case 405: value = 412; break;	/* sqshrun2 --> ushll.  */
25336    case 412: value = 414; break;	/* ushll --> ushll2.  */
25337    case 414: return NULL;		/* ushll2 --> NULL.  */
25338    case 136: value = 384; break;	/* orr --> sqshrn.  */
25339    case 384: value = 385; break;	/* sqshrn --> sqshrn2.  */
25340    case 385: return NULL;		/* sqshrn2 --> NULL.  */
25341    case 144: value = 408; break;	/* bic --> uqshrn.  */
25342    case 408: value = 409; break;	/* uqshrn --> uqshrn2.  */
25343    case 409: return NULL;		/* uqshrn2 --> NULL.  */
25344    case 138: value = 392; break;	/* movi --> scvtf.  */
25345    case 392: value = 393; break;	/* scvtf --> scvtf.  */
25346    case 393: return NULL;		/* scvtf --> NULL.  */
25347    case 146: value = 147; break;	/* movi --> movi.  */
25348    case 147: value = 416; break;	/* movi --> ucvtf.  */
25349    case 416: value = 417; break;	/* ucvtf --> ucvtf.  */
25350    case 417: return NULL;		/* ucvtf --> NULL.  */
25351    case 140: value = 394; break;	/* fmov --> fcvtzs.  */
25352    case 394: value = 395; break;	/* fcvtzs --> fcvtzs.  */
25353    case 395: return NULL;		/* fcvtzs --> NULL.  */
25354    case 418: value = 419; break;	/* fcvtzu --> fcvtzu.  */
25355    case 419: return NULL;		/* fcvtzu --> NULL.  */
25356    case 860: value = 861; break;	/* fmsub --> fmsub.  */
25357    case 861: return NULL;		/* fmsub --> NULL.  */
25358    case 864: value = 865; break;	/* fnmsub --> fnmsub.  */
25359    case 865: return NULL;		/* fnmsub --> NULL.  */
25360    case 598: value = 599; break;	/* scvtf --> scvtf.  */
25361    case 599: return NULL;		/* scvtf --> NULL.  */
25362    case 600: value = 601; break;	/* fcvtzs --> fcvtzs.  */
25363    case 601: return NULL;		/* fcvtzs --> NULL.  */
25364    case 614: value = 615; break;	/* ucvtf --> ucvtf.  */
25365    case 615: return NULL;		/* ucvtf --> NULL.  */
25366    case 616: value = 617; break;	/* fcvtzu --> fcvtzu.  */
25367    case 617: return NULL;		/* fcvtzu --> NULL.  */
25368    default: return NULL;
25369    }
25370
25371  return aarch64_opcode_table + value;
25372}
25373
25374const aarch64_opcode *
25375aarch64_find_alias_opcode (const aarch64_opcode *opcode)
25376{
25377  /* Use the index as the key to locate the alias opcode.  */
25378  int key = opcode - aarch64_opcode_table;
25379  int value;
25380  switch (key)
25381    {
25382    case 2: value = 3; break;	/* sbc --> ngc.  */
25383    case 4: value = 5; break;	/* sbcs --> ngcs.  */
25384    case 7: value = 8; break;	/* adds --> cmn.  */
25385    case 10: value = 11; break;	/* subs --> cmp.  */
25386    case 12: value = 13; break;	/* add --> mov.  */
25387    case 14: value = 15; break;	/* adds --> cmn.  */
25388    case 17: value = 18; break;	/* subs --> cmp.  */
25389    case 22: value = 23; break;	/* adds --> cmn.  */
25390    case 24: value = 25; break;	/* sub --> neg.  */
25391    case 26: value = 27; break;	/* subs --> cmp.  */
25392    case 152: value = 153; break;	/* umov --> mov.  */
25393    case 154: value = 155; break;	/* ins --> mov.  */
25394    case 156: value = 157; break;	/* ins --> mov.  */
25395    case 242: value = 243; break;	/* not --> mvn.  */
25396    case 317: value = 318; break;	/* orr --> mov.  */
25397    case 388: value = 389; break;	/* sshll --> sxtl.  */
25398    case 390: value = 391; break;	/* sshll2 --> sxtl2.  */
25399    case 412: value = 413; break;	/* ushll --> uxtl.  */
25400    case 414: value = 415; break;	/* ushll2 --> uxtl2.  */
25401    case 535: value = 536; break;	/* dup --> mov.  */
25402    case 618: value = 623; break;	/* sbfm --> sxtw.  */
25403    case 625: value = 627; break;	/* bfm --> bfc.  */
25404    case 629: value = 633; break;	/* ubfm --> uxth.  */
25405    case 663: value = 665; break;	/* csinc --> cset.  */
25406    case 666: value = 668; break;	/* csinv --> csetm.  */
25407    case 669: value = 670; break;	/* csneg --> cneg.  */
25408    case 688: value = 688; break;	/* rev --> rev.  */
25409    case 713: value = 714; break;	/* lslv --> lsl.  */
25410    case 715: value = 716; break;	/* lsrv --> lsr.  */
25411    case 717: value = 718; break;	/* asrv --> asr.  */
25412    case 719: value = 720; break;	/* rorv --> ror.  */
25413    case 722: value = 723; break;	/* subps --> cmpp.  */
25414    case 735: value = 736; break;	/* madd --> mul.  */
25415    case 737: value = 738; break;	/* msub --> mneg.  */
25416    case 739: value = 740; break;	/* smaddl --> smull.  */
25417    case 741: value = 742; break;	/* smsubl --> smnegl.  */
25418    case 744: value = 745; break;	/* umaddl --> umull.  */
25419    case 746: value = 747; break;	/* umsubl --> umnegl.  */
25420    case 758: value = 759; break;	/* extr --> ror.  */
25421    case 995: value = 996; break;	/* and --> bic.  */
25422    case 997: value = 998; break;	/* orr --> mov.  */
25423    case 1000: value = 1001; break;	/* ands --> tst.  */
25424    case 1004: value = 1006; break;	/* orr --> uxtw.  */
25425    case 1007: value = 1008; break;	/* orn --> mvn.  */
25426    case 1011: value = 1012; break;	/* ands --> tst.  */
25427    case 1042: value = 1138; break;	/* ldaddb --> staddb.  */
25428    case 1043: value = 1139; break;	/* ldaddh --> staddh.  */
25429    case 1044: value = 1140; break;	/* ldadd --> stadd.  */
25430    case 1046: value = 1141; break;	/* ldaddlb --> staddlb.  */
25431    case 1049: value = 1142; break;	/* ldaddlh --> staddlh.  */
25432    case 1052: value = 1143; break;	/* ldaddl --> staddl.  */
25433    case 1054: value = 1144; break;	/* ldclrb --> stclrb.  */
25434    case 1055: value = 1145; break;	/* ldclrh --> stclrh.  */
25435    case 1056: value = 1146; break;	/* ldclr --> stclr.  */
25436    case 1058: value = 1147; break;	/* ldclrlb --> stclrlb.  */
25437    case 1061: value = 1148; break;	/* ldclrlh --> stclrlh.  */
25438    case 1064: value = 1149; break;	/* ldclrl --> stclrl.  */
25439    case 1066: value = 1150; break;	/* ldeorb --> steorb.  */
25440    case 1067: value = 1151; break;	/* ldeorh --> steorh.  */
25441    case 1068: value = 1152; break;	/* ldeor --> steor.  */
25442    case 1070: value = 1153; break;	/* ldeorlb --> steorlb.  */
25443    case 1073: value = 1154; break;	/* ldeorlh --> steorlh.  */
25444    case 1076: value = 1155; break;	/* ldeorl --> steorl.  */
25445    case 1078: value = 1156; break;	/* ldsetb --> stsetb.  */
25446    case 1079: value = 1157; break;	/* ldseth --> stseth.  */
25447    case 1080: value = 1158; break;	/* ldset --> stset.  */
25448    case 1082: value = 1159; break;	/* ldsetlb --> stsetlb.  */
25449    case 1085: value = 1160; break;	/* ldsetlh --> stsetlh.  */
25450    case 1088: value = 1161; break;	/* ldsetl --> stsetl.  */
25451    case 1090: value = 1162; break;	/* ldsmaxb --> stsmaxb.  */
25452    case 1091: value = 1163; break;	/* ldsmaxh --> stsmaxh.  */
25453    case 1092: value = 1164; break;	/* ldsmax --> stsmax.  */
25454    case 1094: value = 1165; break;	/* ldsmaxlb --> stsmaxlb.  */
25455    case 1097: value = 1166; break;	/* ldsmaxlh --> stsmaxlh.  */
25456    case 1100: value = 1167; break;	/* ldsmaxl --> stsmaxl.  */
25457    case 1102: value = 1168; break;	/* ldsminb --> stsminb.  */
25458    case 1103: value = 1169; break;	/* ldsminh --> stsminh.  */
25459    case 1104: value = 1170; break;	/* ldsmin --> stsmin.  */
25460    case 1106: value = 1171; break;	/* ldsminlb --> stsminlb.  */
25461    case 1109: value = 1172; break;	/* ldsminlh --> stsminlh.  */
25462    case 1112: value = 1173; break;	/* ldsminl --> stsminl.  */
25463    case 1114: value = 1174; break;	/* ldumaxb --> stumaxb.  */
25464    case 1115: value = 1175; break;	/* ldumaxh --> stumaxh.  */
25465    case 1116: value = 1176; break;	/* ldumax --> stumax.  */
25466    case 1118: value = 1177; break;	/* ldumaxlb --> stumaxlb.  */
25467    case 1121: value = 1178; break;	/* ldumaxlh --> stumaxlh.  */
25468    case 1124: value = 1179; break;	/* ldumaxl --> stumaxl.  */
25469    case 1126: value = 1180; break;	/* lduminb --> stuminb.  */
25470    case 1127: value = 1181; break;	/* lduminh --> stuminh.  */
25471    case 1128: value = 1182; break;	/* ldumin --> stumin.  */
25472    case 1130: value = 1183; break;	/* lduminlb --> stuminlb.  */
25473    case 1133: value = 1184; break;	/* lduminlh --> stuminlh.  */
25474    case 1136: value = 1185; break;	/* lduminl --> stuminl.  */
25475    case 1186: value = 1187; break;	/* movn --> mov.  */
25476    case 1188: value = 1189; break;	/* movz --> mov.  */
25477    case 1202: value = 1250; break;	/* hint --> autibsp.  */
25478    case 1221: value = 1225; break;	/* dsb --> pssbb.  */
25479    case 1222: value = 1222; break;	/* dsb --> dsb.  */
25480    case 1229: value = 1238; break;	/* sys --> cpp.  */
25481    case 1234: value = 1234; break;	/* wfet --> wfet.  */
25482    case 1235: value = 1235; break;	/* wfit --> wfit.  */
25483    case 1298: value = 2048; break;	/* and --> bic.  */
25484    case 1300: value = 1281; break;	/* and --> mov.  */
25485    case 1301: value = 1285; break;	/* ands --> movs.  */
25486    case 1336: value = 2049; break;	/* cmpge --> cmple.  */
25487    case 1339: value = 2052; break;	/* cmpgt --> cmplt.  */
25488    case 1341: value = 2050; break;	/* cmphi --> cmplo.  */
25489    case 1344: value = 2051; break;	/* cmphs --> cmpls.  */
25490    case 1366: value = 1278; break;	/* cpy --> mov.  */
25491    case 1367: value = 1280; break;	/* cpy --> mov.  */
25492    case 1368: value = 2059; break;	/* cpy --> fmov.  */
25493    case 1380: value = 1273; break;	/* dup --> mov.  */
25494    case 1381: value = 1275; break;	/* dup --> mov.  */
25495    case 1382: value = 2058; break;	/* dup --> fmov.  */
25496    case 1383: value = 1276; break;	/* dupm --> mov.  */
25497    case 1385: value = 2053; break;	/* eor --> eon.  */
25498    case 1387: value = 1286; break;	/* eor --> not.  */
25499    case 1388: value = 1287; break;	/* eors --> nots.  */
25500    case 1393: value = 2054; break;	/* facge --> facle.  */
25501    case 1394: value = 2055; break;	/* facgt --> faclt.  */
25502    case 1407: value = 2056; break;	/* fcmge --> fcmle.  */
25503    case 1409: value = 2057; break;	/* fcmgt --> fcmlt.  */
25504    case 1415: value = 1270; break;	/* fcpy --> fmov.  */
25505    case 1438: value = 1269; break;	/* fdup --> fmov.  */
25506    case 1769: value = 1271; break;	/* orr --> mov.  */
25507    case 1770: value = 2060; break;	/* orr --> orn.  */
25508    case 1772: value = 1274; break;	/* orr --> mov.  */
25509    case 1773: value = 1284; break;	/* orrs --> movs.  */
25510    case 1835: value = 1279; break;	/* sel --> mov.  */
25511    case 1836: value = 1282; break;	/* sel --> mov.  */
25512    default: return NULL;
25513    }
25514
25515  return aarch64_opcode_table + value;
25516}
25517
25518const aarch64_opcode *
25519aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
25520{
25521  /* Use the index as the key to locate the next opcode.  */
25522  int key = opcode - aarch64_opcode_table;
25523  int value;
25524  switch (key)
25525    {
25526    case 3: value = 2; break;	/* ngc --> sbc.  */
25527    case 5: value = 4; break;	/* ngcs --> sbcs.  */
25528    case 8: value = 7; break;	/* cmn --> adds.  */
25529    case 11: value = 10; break;	/* cmp --> subs.  */
25530    case 13: value = 12; break;	/* mov --> add.  */
25531    case 15: value = 14; break;	/* cmn --> adds.  */
25532    case 18: value = 17; break;	/* cmp --> subs.  */
25533    case 23: value = 22; break;	/* cmn --> adds.  */
25534    case 25: value = 24; break;	/* neg --> sub.  */
25535    case 27: value = 28; break;	/* cmp --> negs.  */
25536    case 28: value = 26; break;	/* negs --> subs.  */
25537    case 153: value = 152; break;	/* mov --> umov.  */
25538    case 155: value = 154; break;	/* mov --> ins.  */
25539    case 157: value = 156; break;	/* mov --> ins.  */
25540    case 243: value = 242; break;	/* mvn --> not.  */
25541    case 318: value = 317; break;	/* mov --> orr.  */
25542    case 389: value = 388; break;	/* sxtl --> sshll.  */
25543    case 391: value = 390; break;	/* sxtl2 --> sshll2.  */
25544    case 413: value = 412; break;	/* uxtl --> ushll.  */
25545    case 415: value = 414; break;	/* uxtl2 --> ushll2.  */
25546    case 536: value = 535; break;	/* mov --> dup.  */
25547    case 623: value = 622; break;	/* sxtw --> sxth.  */
25548    case 622: value = 621; break;	/* sxth --> sxtb.  */
25549    case 621: value = 624; break;	/* sxtb --> asr.  */
25550    case 624: value = 620; break;	/* asr --> sbfx.  */
25551    case 620: value = 619; break;	/* sbfx --> sbfiz.  */
25552    case 619: value = 618; break;	/* sbfiz --> sbfm.  */
25553    case 627: value = 628; break;	/* bfc --> bfxil.  */
25554    case 628: value = 626; break;	/* bfxil --> bfi.  */
25555    case 626: value = 625; break;	/* bfi --> bfm.  */
25556    case 633: value = 632; break;	/* uxth --> uxtb.  */
25557    case 632: value = 635; break;	/* uxtb --> lsr.  */
25558    case 635: value = 634; break;	/* lsr --> lsl.  */
25559    case 634: value = 631; break;	/* lsl --> ubfx.  */
25560    case 631: value = 630; break;	/* ubfx --> ubfiz.  */
25561    case 630: value = 629; break;	/* ubfiz --> ubfm.  */
25562    case 665: value = 664; break;	/* cset --> cinc.  */
25563    case 664: value = 663; break;	/* cinc --> csinc.  */
25564    case 668: value = 667; break;	/* csetm --> cinv.  */
25565    case 667: value = 666; break;	/* cinv --> csinv.  */
25566    case 670: value = 669; break;	/* cneg --> csneg.  */
25567    case 688: value = 689; break;	/* rev --> rev64.  */
25568    case 714: value = 713; break;	/* lsl --> lslv.  */
25569    case 716: value = 715; break;	/* lsr --> lsrv.  */
25570    case 718: value = 717; break;	/* asr --> asrv.  */
25571    case 720: value = 719; break;	/* ror --> rorv.  */
25572    case 723: value = 722; break;	/* cmpp --> subps.  */
25573    case 736: value = 735; break;	/* mul --> madd.  */
25574    case 738: value = 737; break;	/* mneg --> msub.  */
25575    case 740: value = 739; break;	/* smull --> smaddl.  */
25576    case 742: value = 741; break;	/* smnegl --> smsubl.  */
25577    case 745: value = 744; break;	/* umull --> umaddl.  */
25578    case 747: value = 746; break;	/* umnegl --> umsubl.  */
25579    case 759: value = 758; break;	/* ror --> extr.  */
25580    case 996: value = 995; break;	/* bic --> and.  */
25581    case 998: value = 997; break;	/* mov --> orr.  */
25582    case 1001: value = 1000; break;	/* tst --> ands.  */
25583    case 1006: value = 1005; break;	/* uxtw --> mov.  */
25584    case 1005: value = 1004; break;	/* mov --> orr.  */
25585    case 1008: value = 1007; break;	/* mvn --> orn.  */
25586    case 1012: value = 1011; break;	/* tst --> ands.  */
25587    case 1138: value = 1042; break;	/* staddb --> ldaddb.  */
25588    case 1139: value = 1043; break;	/* staddh --> ldaddh.  */
25589    case 1140: value = 1044; break;	/* stadd --> ldadd.  */
25590    case 1141: value = 1046; break;	/* staddlb --> ldaddlb.  */
25591    case 1142: value = 1049; break;	/* staddlh --> ldaddlh.  */
25592    case 1143: value = 1052; break;	/* staddl --> ldaddl.  */
25593    case 1144: value = 1054; break;	/* stclrb --> ldclrb.  */
25594    case 1145: value = 1055; break;	/* stclrh --> ldclrh.  */
25595    case 1146: value = 1056; break;	/* stclr --> ldclr.  */
25596    case 1147: value = 1058; break;	/* stclrlb --> ldclrlb.  */
25597    case 1148: value = 1061; break;	/* stclrlh --> ldclrlh.  */
25598    case 1149: value = 1064; break;	/* stclrl --> ldclrl.  */
25599    case 1150: value = 1066; break;	/* steorb --> ldeorb.  */
25600    case 1151: value = 1067; break;	/* steorh --> ldeorh.  */
25601    case 1152: value = 1068; break;	/* steor --> ldeor.  */
25602    case 1153: value = 1070; break;	/* steorlb --> ldeorlb.  */
25603    case 1154: value = 1073; break;	/* steorlh --> ldeorlh.  */
25604    case 1155: value = 1076; break;	/* steorl --> ldeorl.  */
25605    case 1156: value = 1078; break;	/* stsetb --> ldsetb.  */
25606    case 1157: value = 1079; break;	/* stseth --> ldseth.  */
25607    case 1158: value = 1080; break;	/* stset --> ldset.  */
25608    case 1159: value = 1082; break;	/* stsetlb --> ldsetlb.  */
25609    case 1160: value = 1085; break;	/* stsetlh --> ldsetlh.  */
25610    case 1161: value = 1088; break;	/* stsetl --> ldsetl.  */
25611    case 1162: value = 1090; break;	/* stsmaxb --> ldsmaxb.  */
25612    case 1163: value = 1091; break;	/* stsmaxh --> ldsmaxh.  */
25613    case 1164: value = 1092; break;	/* stsmax --> ldsmax.  */
25614    case 1165: value = 1094; break;	/* stsmaxlb --> ldsmaxlb.  */
25615    case 1166: value = 1097; break;	/* stsmaxlh --> ldsmaxlh.  */
25616    case 1167: value = 1100; break;	/* stsmaxl --> ldsmaxl.  */
25617    case 1168: value = 1102; break;	/* stsminb --> ldsminb.  */
25618    case 1169: value = 1103; break;	/* stsminh --> ldsminh.  */
25619    case 1170: value = 1104; break;	/* stsmin --> ldsmin.  */
25620    case 1171: value = 1106; break;	/* stsminlb --> ldsminlb.  */
25621    case 1172: value = 1109; break;	/* stsminlh --> ldsminlh.  */
25622    case 1173: value = 1112; break;	/* stsminl --> ldsminl.  */
25623    case 1174: value = 1114; break;	/* stumaxb --> ldumaxb.  */
25624    case 1175: value = 1115; break;	/* stumaxh --> ldumaxh.  */
25625    case 1176: value = 1116; break;	/* stumax --> ldumax.  */
25626    case 1177: value = 1118; break;	/* stumaxlb --> ldumaxlb.  */
25627    case 1178: value = 1121; break;	/* stumaxlh --> ldumaxlh.  */
25628    case 1179: value = 1124; break;	/* stumaxl --> ldumaxl.  */
25629    case 1180: value = 1126; break;	/* stuminb --> lduminb.  */
25630    case 1181: value = 1127; break;	/* stuminh --> lduminh.  */
25631    case 1182: value = 1128; break;	/* stumin --> ldumin.  */
25632    case 1183: value = 1130; break;	/* stuminlb --> lduminlb.  */
25633    case 1184: value = 1133; break;	/* stuminlh --> lduminlh.  */
25634    case 1185: value = 1136; break;	/* stuminl --> lduminl.  */
25635    case 1187: value = 1186; break;	/* mov --> movn.  */
25636    case 1189: value = 1188; break;	/* mov --> movz.  */
25637    case 1250: value = 1249; break;	/* autibsp --> autibz.  */
25638    case 1249: value = 1248; break;	/* autibz --> autiasp.  */
25639    case 1248: value = 1247; break;	/* autiasp --> autiaz.  */
25640    case 1247: value = 1246; break;	/* autiaz --> pacibsp.  */
25641    case 1246: value = 1245; break;	/* pacibsp --> pacibz.  */
25642    case 1245: value = 1244; break;	/* pacibz --> paciasp.  */
25643    case 1244: value = 1243; break;	/* paciasp --> paciaz.  */
25644    case 1243: value = 1219; break;	/* paciaz --> tsb.  */
25645    case 1219: value = 1218; break;	/* tsb --> psb.  */
25646    case 1218: value = 1217; break;	/* psb --> esb.  */
25647    case 1217: value = 1216; break;	/* esb --> autib1716.  */
25648    case 1216: value = 1215; break;	/* autib1716 --> autia1716.  */
25649    case 1215: value = 1214; break;	/* autia1716 --> pacib1716.  */
25650    case 1214: value = 1213; break;	/* pacib1716 --> pacia1716.  */
25651    case 1213: value = 1212; break;	/* pacia1716 --> xpaclri.  */
25652    case 1212: value = 1210; break;	/* xpaclri --> sevl.  */
25653    case 1210: value = 1209; break;	/* sevl --> sev.  */
25654    case 1209: value = 1208; break;	/* sev --> wfi.  */
25655    case 1208: value = 1207; break;	/* wfi --> wfe.  */
25656    case 1207: value = 1206; break;	/* wfe --> yield.  */
25657    case 1206: value = 1205; break;	/* yield --> bti.  */
25658    case 1205: value = 1204; break;	/* bti --> csdb.  */
25659    case 1204: value = 1203; break;	/* csdb --> nop.  */
25660    case 1203: value = 1202; break;	/* nop --> hint.  */
25661    case 1225: value = 1224; break;	/* pssbb --> ssbb.  */
25662    case 1224: value = 1223; break;	/* ssbb --> dfb.  */
25663    case 1223: value = 1221; break;	/* dfb --> dsb.  */
25664    case 1238: value = 1237; break;	/* cpp --> dvp.  */
25665    case 1237: value = 1236; break;	/* dvp --> cfp.  */
25666    case 1236: value = 1233; break;	/* cfp --> tlbi.  */
25667    case 1233: value = 1232; break;	/* tlbi --> ic.  */
25668    case 1232: value = 1231; break;	/* ic --> dc.  */
25669    case 1231: value = 1230; break;	/* dc --> at.  */
25670    case 1230: value = 1229; break;	/* at --> sys.  */
25671    case 2048: value = 1298; break;	/* bic --> and.  */
25672    case 1281: value = 1300; break;	/* mov --> and.  */
25673    case 1285: value = 1301; break;	/* movs --> ands.  */
25674    case 2049: value = 1336; break;	/* cmple --> cmpge.  */
25675    case 2052: value = 1339; break;	/* cmplt --> cmpgt.  */
25676    case 2050: value = 1341; break;	/* cmplo --> cmphi.  */
25677    case 2051: value = 1344; break;	/* cmpls --> cmphs.  */
25678    case 1278: value = 1366; break;	/* mov --> cpy.  */
25679    case 1280: value = 1367; break;	/* mov --> cpy.  */
25680    case 2059: value = 1283; break;	/* fmov --> mov.  */
25681    case 1283: value = 1368; break;	/* mov --> cpy.  */
25682    case 1273: value = 1380; break;	/* mov --> dup.  */
25683    case 1275: value = 1272; break;	/* mov --> mov.  */
25684    case 1272: value = 1381; break;	/* mov --> dup.  */
25685    case 2058: value = 1277; break;	/* fmov --> mov.  */
25686    case 1277: value = 1382; break;	/* mov --> dup.  */
25687    case 1276: value = 1383; break;	/* mov --> dupm.  */
25688    case 2053: value = 1385; break;	/* eon --> eor.  */
25689    case 1286: value = 1387; break;	/* not --> eor.  */
25690    case 1287: value = 1388; break;	/* nots --> eors.  */
25691    case 2054: value = 1393; break;	/* facle --> facge.  */
25692    case 2055: value = 1394; break;	/* faclt --> facgt.  */
25693    case 2056: value = 1407; break;	/* fcmle --> fcmge.  */
25694    case 2057: value = 1409; break;	/* fcmlt --> fcmgt.  */
25695    case 1270: value = 1415; break;	/* fmov --> fcpy.  */
25696    case 1269: value = 1438; break;	/* fmov --> fdup.  */
25697    case 1271: value = 1769; break;	/* mov --> orr.  */
25698    case 2060: value = 1770; break;	/* orn --> orr.  */
25699    case 1274: value = 1772; break;	/* mov --> orr.  */
25700    case 1284: value = 1773; break;	/* movs --> orrs.  */
25701    case 1279: value = 1835; break;	/* mov --> sel.  */
25702    case 1282: value = 1836; break;	/* mov --> sel.  */
25703    default: return NULL;
25704    }
25705
25706  return aarch64_opcode_table + value;
25707}
25708
25709bool
25710aarch64_extract_operand (const aarch64_operand *self,
25711			   aarch64_opnd_info *info,
25712			   aarch64_insn code, const aarch64_inst *inst,
25713			   aarch64_operand_error *errors)
25714{
25715  /* Use the index as the key.  */
25716  int key = self - aarch64_operands;
25717  switch (key)
25718    {
25719    case 1:
25720    case 2:
25721    case 3:
25722    case 4:
25723    case 5:
25724    case 6:
25725    case 7:
25726    case 8:
25727    case 9:
25728    case 11:
25729    case 12:
25730    case 13:
25731    case 17:
25732    case 18:
25733    case 19:
25734    case 20:
25735    case 22:
25736    case 23:
25737    case 24:
25738    case 25:
25739    case 26:
25740    case 27:
25741    case 28:
25742    case 29:
25743    case 30:
25744    case 31:
25745    case 167:
25746    case 168:
25747    case 169:
25748    case 170:
25749    case 171:
25750    case 172:
25751    case 173:
25752    case 174:
25753    case 175:
25754    case 176:
25755    case 191:
25756    case 192:
25757    case 193:
25758    case 194:
25759    case 195:
25760    case 196:
25761    case 197:
25762    case 198:
25763    case 199:
25764    case 205:
25765    case 208:
25766    case 210:
25767    case 211:
25768    case 214:
25769      return aarch64_ext_regno (self, info, code, inst, errors);
25770    case 10:
25771      return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
25772    case 14:
25773      return aarch64_ext_regno_pair (self, info, code, inst, errors);
25774    case 15:
25775      return aarch64_ext_reg_extended (self, info, code, inst, errors);
25776    case 16:
25777      return aarch64_ext_reg_shifted (self, info, code, inst, errors);
25778    case 21:
25779      return aarch64_ext_ft (self, info, code, inst, errors);
25780    case 32:
25781    case 33:
25782    case 34:
25783    case 35:
25784    case 222:
25785      return aarch64_ext_reglane (self, info, code, inst, errors);
25786    case 36:
25787      return aarch64_ext_reglist (self, info, code, inst, errors);
25788    case 37:
25789      return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
25790    case 38:
25791      return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
25792    case 39:
25793      return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
25794    case 40:
25795    case 41:
25796    case 42:
25797    case 43:
25798    case 53:
25799    case 54:
25800    case 55:
25801    case 56:
25802    case 57:
25803    case 58:
25804    case 59:
25805    case 60:
25806    case 61:
25807    case 62:
25808    case 63:
25809    case 64:
25810    case 65:
25811    case 66:
25812    case 67:
25813    case 68:
25814    case 69:
25815    case 80:
25816    case 81:
25817    case 82:
25818    case 83:
25819    case 84:
25820    case 164:
25821    case 166:
25822    case 183:
25823    case 184:
25824    case 185:
25825    case 186:
25826    case 187:
25827    case 188:
25828    case 189:
25829    case 190:
25830    case 215:
25831    case 221:
25832      return aarch64_ext_imm (self, info, code, inst, errors);
25833    case 44:
25834    case 45:
25835      return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
25836    case 46:
25837    case 47:
25838    case 48:
25839      return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
25840    case 49:
25841      return aarch64_ext_shll_imm (self, info, code, inst, errors);
25842    case 52:
25843    case 154:
25844      return aarch64_ext_fpimm (self, info, code, inst, errors);
25845    case 70:
25846    case 162:
25847      return aarch64_ext_limm (self, info, code, inst, errors);
25848    case 71:
25849      return aarch64_ext_aimm (self, info, code, inst, errors);
25850    case 72:
25851      return aarch64_ext_imm_half (self, info, code, inst, errors);
25852    case 73:
25853      return aarch64_ext_fbits (self, info, code, inst, errors);
25854    case 75:
25855    case 76:
25856    case 159:
25857      return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
25858    case 77:
25859    case 158:
25860    case 160:
25861      return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
25862    case 78:
25863    case 79:
25864      return aarch64_ext_cond (self, info, code, inst, errors);
25865    case 85:
25866    case 94:
25867      return aarch64_ext_addr_simple (self, info, code, inst, errors);
25868    case 86:
25869      return aarch64_ext_addr_regoff (self, info, code, inst, errors);
25870    case 87:
25871    case 88:
25872    case 89:
25873    case 91:
25874    case 93:
25875      return aarch64_ext_addr_simm (self, info, code, inst, errors);
25876    case 90:
25877      return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
25878    case 92:
25879      return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
25880    case 95:
25881      return aarch64_ext_addr_offset (self, info, code, inst, errors);
25882    case 96:
25883      return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
25884    case 97:
25885      return aarch64_ext_sysreg (self, info, code, inst, errors);
25886    case 98:
25887      return aarch64_ext_pstatefield (self, info, code, inst, errors);
25888    case 99:
25889    case 100:
25890    case 101:
25891    case 102:
25892    case 103:
25893      return aarch64_ext_sysins_op (self, info, code, inst, errors);
25894    case 104:
25895    case 106:
25896      return aarch64_ext_barrier (self, info, code, inst, errors);
25897    case 105:
25898      return aarch64_ext_barrier_dsb_nxs (self, info, code, inst, errors);
25899    case 107:
25900      return aarch64_ext_prfop (self, info, code, inst, errors);
25901    case 108:
25902      return aarch64_ext_none (self, info, code, inst, errors);
25903    case 109:
25904      return aarch64_ext_hint (self, info, code, inst, errors);
25905    case 110:
25906    case 111:
25907      return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
25908    case 112:
25909    case 113:
25910    case 114:
25911    case 115:
25912      return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
25913    case 116:
25914      return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
25915    case 117:
25916      return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
25917    case 118:
25918    case 119:
25919    case 120:
25920    case 121:
25921      return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
25922    case 122:
25923    case 123:
25924    case 124:
25925    case 125:
25926    case 126:
25927    case 127:
25928    case 128:
25929    case 129:
25930    case 130:
25931    case 131:
25932    case 132:
25933    case 133:
25934    case 134:
25935    case 135:
25936    case 136:
25937      return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
25938    case 137:
25939    case 138:
25940    case 139:
25941    case 140:
25942    case 141:
25943    case 142:
25944    case 143:
25945    case 144:
25946      return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
25947    case 145:
25948    case 146:
25949    case 147:
25950    case 148:
25951      return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
25952    case 149:
25953      return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
25954    case 150:
25955      return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
25956    case 151:
25957      return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
25958    case 152:
25959      return aarch64_ext_sve_aimm (self, info, code, inst, errors);
25960    case 153:
25961      return aarch64_ext_sve_asimm (self, info, code, inst, errors);
25962    case 155:
25963      return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
25964    case 156:
25965      return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
25966    case 157:
25967      return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
25968    case 161:
25969      return aarch64_ext_inv_limm (self, info, code, inst, errors);
25970    case 163:
25971      return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
25972    case 165:
25973      return aarch64_ext_sve_scale (self, info, code, inst, errors);
25974    case 177:
25975    case 178:
25976    case 179:
25977      return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
25978    case 180:
25979    case 181:
25980    case 182:
25981      return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
25982    case 200:
25983    case 201:
25984    case 202:
25985    case 203:
25986    case 204:
25987      return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
25988    case 206:
25989      return aarch64_ext_sve_index (self, info, code, inst, errors);
25990    case 207:
25991    case 209:
25992      return aarch64_ext_sve_reglist (self, info, code, inst, errors);
25993    case 212:
25994    case 213:
25995    case 216:
25996      return aarch64_ext_sme_za_hv_tiles (self, info, code, inst, errors);
25997    case 217:
25998      return aarch64_ext_sme_za_array (self, info, code, inst, errors);
25999    case 218:
26000      return aarch64_ext_sme_addr_ri_u4xvl (self, info, code, inst, errors);
26001    case 219:
26002      return aarch64_ext_sme_sm_za (self, info, code, inst, errors);
26003    case 220:
26004      return aarch64_ext_sme_pred_reg_with_index (self, info, code, inst, errors);
26005    case 223:
26006    case 224:
26007    case 225:
26008      return aarch64_ext_x0_to_x30 (self, info, code, inst, errors);
26009    default: assert (0); abort ();
26010    }
26011}
26012