1/* This file is automatically generated by aarch64-gen.  Do not edit!  */
2/* Copyright (C) 2012-2024 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 >> 3) & 0x1) == 0)
58                                            {
59                                              if (((word >> 4) & 0x1) == 0)
60                                                {
61                                                  /* 33222222222211111111110000000000
62                                                     10987654321098765432109876543210
63                                                     x0000000100xxxxxxxxxxxxxxxx00xxx
64                                                     fmopa.  */
65                                                  return 2402;
66                                                }
67                                              else
68                                                {
69                                                  /* 33222222222211111111110000000000
70                                                     10987654321098765432109876543210
71                                                     x0000000100xxxxxxxxxxxxxxxx10xxx
72                                                     fmops.  */
73                                                  return 2405;
74                                                }
75                                            }
76                                          else
77                                            {
78                                              if (((word >> 4) & 0x1) == 0)
79                                                {
80                                                  /* 33222222222211111111110000000000
81                                                     10987654321098765432109876543210
82                                                     x0000000100xxxxxxxxxxxxxxxx01xxx
83                                                     bmopa.  */
84                                                  return 2516;
85                                                }
86                                              else
87                                                {
88                                                  /* 33222222222211111111110000000000
89                                                     10987654321098765432109876543210
90                                                     x0000000100xxxxxxxxxxxxxxxx11xxx
91                                                     bmops.  */
92                                                  return 2517;
93                                                }
94                                            }
95                                        }
96                                    }
97                                  else
98                                    {
99                                      if (((word >> 4) & 0x1) == 0)
100                                        {
101                                          /* 33222222222211111111110000000000
102                                             10987654321098765432109876543210
103                                             x0000000x10xxxxxxxxxxxxxxxx0xxxx
104                                             fmopa.  */
105                                          return 2403;
106                                        }
107                                      else
108                                        {
109                                          /* 33222222222211111111110000000000
110                                             10987654321098765432109876543210
111                                             x0000000x10xxxxxxxxxxxxxxxx1xxxx
112                                             fmops.  */
113                                          return 2406;
114                                        }
115                                    }
116                                }
117                              else
118                                {
119                                  if (((word >> 18) & 0x1) == 0)
120                                    {
121                                      if (((word >> 17) & 0x1) == 0)
122                                        {
123                                          if (((word >> 19) & 0x1) == 0)
124                                            {
125                                              if (((word >> 20) & 0x1) == 0)
126                                                {
127                                                  /* 33222222222211111111110000000000
128                                                     10987654321098765432109876543210
129                                                     x1000000xx00000xxxxxxxxxxxxxxxxx
130                                                     mov.  */
131                                                  return 2426;
132                                                }
133                                              else
134                                                {
135                                                  if (((word >> 16) & 0x1) == 0)
136                                                    {
137                                                      if (((word >> 22) & 0x1) == 0)
138                                                        {
139                                                          /* 33222222222211111111110000000000
140                                                             10987654321098765432109876543210
141                                                             x1000000x0010000xxxxxxxxxxxxxxxx
142                                                             addha.  */
143                                                          return 2394;
144                                                        }
145                                                      else
146                                                        {
147                                                          /* 33222222222211111111110000000000
148                                                             10987654321098765432109876543210
149                                                             x1000000x1010000xxxxxxxxxxxxxxxx
150                                                             addha.  */
151                                                          return 2395;
152                                                        }
153                                                    }
154                                                  else
155                                                    {
156                                                      if (((word >> 22) & 0x1) == 0)
157                                                        {
158                                                          /* 33222222222211111111110000000000
159                                                             10987654321098765432109876543210
160                                                             x1000000x0010001xxxxxxxxxxxxxxxx
161                                                             addva.  */
162                                                          return 2398;
163                                                        }
164                                                      else
165                                                        {
166                                                          /* 33222222222211111111110000000000
167                                                             10987654321098765432109876543210
168                                                             x1000000x1010001xxxxxxxxxxxxxxxx
169                                                             addva.  */
170                                                          return 2399;
171                                                        }
172                                                    }
173                                                }
174                                            }
175                                          else
176                                            {
177                                              if (((word >> 22) & 0x1) == 0)
178                                                {
179                                                  /* 33222222222211111111110000000000
180                                                     10987654321098765432109876543210
181                                                     x1000000x00x100xxxxxxxxxxxxxxxxx
182                                                     zero.  */
183                                                  return 2429;
184                                                }
185                                              else
186                                                {
187                                                  /* 33222222222211111111110000000000
188                                                     10987654321098765432109876543210
189                                                     x1000000x10x100xxxxxxxxxxxxxxxxx
190                                                     zero.  */
191                                                  return 2946;
192                                                }
193                                            }
194                                        }
195                                      else
196                                        {
197                                          if (((word >> 19) & 0x1) == 0)
198                                            {
199                                              /* 33222222222211111111110000000000
200                                                 10987654321098765432109876543210
201                                                 x1000000xx0x001xxxxxxxxxxxxxxxxx
202                                                 mov.  */
203                                              return 2425;
204                                            }
205                                          else
206                                            {
207                                              if (((word >> 22) & 0x1) == 0)
208                                                {
209                                                  if (((word >> 14) & 0x1) == 0)
210                                                    {
211                                                      /* 33222222222211111111110000000000
212                                                         10987654321098765432109876543210
213                                                         x1000000x00x101xx0xxxxxxxxxxxxxx
214                                                         luti4.  */
215                                                      return 2660;
216                                                    }
217                                                  else
218                                                    {
219                                                      /* 33222222222211111111110000000000
220                                                         10987654321098765432109876543210
221                                                         x1000000x00x101xx1xxxxxxxxxxxxxx
222                                                         luti4.  */
223                                                      return 2659;
224                                                    }
225                                                }
226                                              else
227                                                {
228                                                  /* 33222222222211111111110000000000
229                                                     10987654321098765432109876543210
230                                                     x1000000x10x101xxxxxxxxxxxxxxxxx
231                                                     luti4.  */
232                                                  return 2658;
233                                                }
234                                            }
235                                        }
236                                    }
237                                  else
238                                    {
239                                      if (((word >> 10) & 0x1) == 0)
240                                        {
241                                          if (((word >> 11) & 0x1) == 0)
242                                            {
243                                              if (((word >> 19) & 0x1) == 0)
244                                                {
245                                                  if (((word >> 17) & 0x1) == 0)
246                                                    {
247                                                      /* 33222222222211111111110000000000
248                                                         10987654321098765432109876543210
249                                                         x1000000xx0x010xxxxx00xxxxxxxxxx
250                                                         mov.  */
251                                                      return 2667;
252                                                    }
253                                                  else
254                                                    {
255                                                      if (((word >> 9) & 0x1) == 0)
256                                                        {
257                                                          /* 33222222222211111111110000000000
258                                                             10987654321098765432109876543210
259                                                             x1000000xx0x011xxxxx000xxxxxxxxx
260                                                             mov.  */
261                                                          return 2663;
262                                                        }
263                                                      else
264                                                        {
265                                                          if (((word >> 22) & 0x1) == 0)
266                                                            {
267                                                              if (((word >> 23) & 0x1) == 0)
268                                                                {
269                                                                  /* 33222222222211111111110000000000
270                                                                     10987654321098765432109876543210
271                                                                     x1000000000x011xxxxx001xxxxxxxxx
272                                                                     movaz.  */
273                                                                  return 3291;
274                                                                }
275                                                              else
276                                                                {
277                                                                  /* 33222222222211111111110000000000
278                                                                     10987654321098765432109876543210
279                                                                     x1000000100x011xxxxx001xxxxxxxxx
280                                                                     movaz.  */
281                                                                  return 3293;
282                                                                }
283                                                            }
284                                                          else
285                                                            {
286                                                              if (((word >> 23) & 0x1) == 0)
287                                                                {
288                                                                  /* 33222222222211111111110000000000
289                                                                     10987654321098765432109876543210
290                                                                     x1000000010x011xxxxx001xxxxxxxxx
291                                                                     movaz.  */
292                                                                  return 3292;
293                                                                }
294                                                              else
295                                                                {
296                                                                  /* 33222222222211111111110000000000
297                                                                     10987654321098765432109876543210
298                                                                     x1000000110x011xxxxx001xxxxxxxxx
299                                                                     movaz.  */
300                                                                  return 3294;
301                                                                }
302                                                            }
303                                                        }
304                                                    }
305                                                }
306                                              else
307                                                {
308                                                  if (((word >> 22) & 0x1) == 0)
309                                                    {
310                                                      if (((word >> 14) & 0x1) == 0)
311                                                        {
312                                                          /* 33222222222211111111110000000000
313                                                             10987654321098765432109876543210
314                                                             x1000000x00x11xxx0xx00xxxxxxxxxx
315                                                             luti2.  */
316                                                          return 2657;
317                                                        }
318                                                      else
319                                                        {
320                                                          /* 33222222222211111111110000000000
321                                                             10987654321098765432109876543210
322                                                             x1000000x00x11xxx1xx00xxxxxxxxxx
323                                                             luti2.  */
324                                                          return 2656;
325                                                        }
326                                                    }
327                                                  else
328                                                    {
329                                                      if (((word >> 23) & 0x1) == 0)
330                                                        {
331                                                          if (((word >> 17) & 0x1) == 0)
332                                                            {
333                                                              /* 33222222222211111111110000000000
334                                                                 10987654321098765432109876543210
335                                                                 x1000000010x110xxxxx00xxxxxxxxxx
336                                                                 movt.  */
337                                                              return 2678;
338                                                            }
339                                                          else
340                                                            {
341                                                              /* 33222222222211111111110000000000
342                                                                 10987654321098765432109876543210
343                                                                 x1000000010x111xxxxx00xxxxxxxxxx
344                                                                 movt.  */
345                                                              return 2677;
346                                                            }
347                                                        }
348                                                      else
349                                                        {
350                                                          /* 33222222222211111111110000000000
351                                                             10987654321098765432109876543210
352                                                             x1000000110x11xxxxxx00xxxxxxxxxx
353                                                             luti2.  */
354                                                          return 2655;
355                                                        }
356                                                    }
357                                                }
358                                            }
359                                          else
360                                            {
361                                              if (((word >> 17) & 0x1) == 0)
362                                                {
363                                                  /* 33222222222211111111110000000000
364                                                     10987654321098765432109876543210
365                                                     x1000000xx0xx10xxxxx10xxxxxxxxxx
366                                                     mov.  */
367                                                  return 2665;
368                                                }
369                                              else
370                                                {
371                                                  /* 33222222222211111111110000000000
372                                                     10987654321098765432109876543210
373                                                     x1000000xx0xx11xxxxx10xxxxxxxxxx
374                                                     mov.  */
375                                                  return 2661;
376                                                }
377                                            }
378                                        }
379                                      else
380                                        {
381                                          if (((word >> 11) & 0x1) == 0)
382                                            {
383                                              if (((word >> 17) & 0x1) == 0)
384                                                {
385                                                  /* 33222222222211111111110000000000
386                                                     10987654321098765432109876543210
387                                                     x1000000xx0xx10xxxxx01xxxxxxxxxx
388                                                     mov.  */
389                                                  return 2668;
390                                                }
391                                              else
392                                                {
393                                                  if (((word >> 9) & 0x1) == 0)
394                                                    {
395                                                      /* 33222222222211111111110000000000
396                                                         10987654321098765432109876543210
397                                                         x1000000xx0xx11xxxxx010xxxxxxxxx
398                                                         mov.  */
399                                                      return 2664;
400                                                    }
401                                                  else
402                                                    {
403                                                      if (((word >> 22) & 0x1) == 0)
404                                                        {
405                                                          if (((word >> 23) & 0x1) == 0)
406                                                            {
407                                                              /* 33222222222211111111110000000000
408                                                                 10987654321098765432109876543210
409                                                                 x1000000000xx11xxxxx011xxxxxxxxx
410                                                                 movaz.  */
411                                                              return 3287;
412                                                            }
413                                                          else
414                                                            {
415                                                              /* 33222222222211111111110000000000
416                                                                 10987654321098765432109876543210
417                                                                 x1000000100xx11xxxxx011xxxxxxxxx
418                                                                 movaz.  */
419                                                              return 3289;
420                                                            }
421                                                        }
422                                                      else
423                                                        {
424                                                          if (((word >> 23) & 0x1) == 0)
425                                                            {
426                                                              /* 33222222222211111111110000000000
427                                                                 10987654321098765432109876543210
428                                                                 x1000000010xx11xxxxx011xxxxxxxxx
429                                                                 movaz.  */
430                                                              return 3288;
431                                                            }
432                                                          else
433                                                            {
434                                                              /* 33222222222211111111110000000000
435                                                                 10987654321098765432109876543210
436                                                                 x1000000110xx11xxxxx011xxxxxxxxx
437                                                                 movaz.  */
438                                                              return 3290;
439                                                            }
440                                                        }
441                                                    }
442                                                }
443                                            }
444                                          else
445                                            {
446                                              if (((word >> 17) & 0x1) == 0)
447                                                {
448                                                  /* 33222222222211111111110000000000
449                                                     10987654321098765432109876543210
450                                                     x1000000xx0xx10xxxxx11xxxxxxxxxx
451                                                     mov.  */
452                                                  return 2666;
453                                                }
454                                              else
455                                                {
456                                                  /* 33222222222211111111110000000000
457                                                     10987654321098765432109876543210
458                                                     x1000000xx0xx11xxxxx11xxxxxxxxxx
459                                                     mov.  */
460                                                  return 2662;
461                                                }
462                                            }
463                                        }
464                                    }
465                                }
466                            }
467                          else
468                            {
469                              if (((word >> 22) & 0x1) == 0)
470                                {
471                                  if (((word >> 23) & 0x1) == 0)
472                                    {
473                                      if (((word >> 30) & 0x1) == 0)
474                                        {
475                                          if (((word >> 0) & 0x1) == 0)
476                                            {
477                                              if (((word >> 13) & 0x1) == 0)
478                                                {
479                                                  if (((word >> 14) & 0x1) == 0)
480                                                    {
481                                                      if (((word >> 15) & 0x1) == 0)
482                                                        {
483                                                          /* 33222222222211111111110000000000
484                                                             10987654321098765432109876543210
485                                                             x0100000000xxxxx000xxxxxxxxxxxx0
486                                                             ld1b.  */
487                                                          return 2594;
488                                                        }
489                                                      else
490                                                        {
491                                                          /* 33222222222211111111110000000000
492                                                             10987654321098765432109876543210
493                                                             x0100000000xxxxx100xxxxxxxxxxxx0
494                                                             ld1b.  */
495                                                          return 2595;
496                                                        }
497                                                    }
498                                                  else
499                                                    {
500                                                      if (((word >> 15) & 0x1) == 0)
501                                                        {
502                                                          /* 33222222222211111111110000000000
503                                                             10987654321098765432109876543210
504                                                             x0100000000xxxxx010xxxxxxxxxxxx0
505                                                             ld1w.  */
506                                                          return 2618;
507                                                        }
508                                                      else
509                                                        {
510                                                          /* 33222222222211111111110000000000
511                                                             10987654321098765432109876543210
512                                                             x0100000000xxxxx110xxxxxxxxxxxx0
513                                                             ld1w.  */
514                                                          return 2619;
515                                                        }
516                                                    }
517                                                }
518                                              else
519                                                {
520                                                  if (((word >> 14) & 0x1) == 0)
521                                                    {
522                                                      if (((word >> 15) & 0x1) == 0)
523                                                        {
524                                                          /* 33222222222211111111110000000000
525                                                             10987654321098765432109876543210
526                                                             x0100000000xxxxx001xxxxxxxxxxxx0
527                                                             ld1h.  */
528                                                          return 2610;
529                                                        }
530                                                      else
531                                                        {
532                                                          /* 33222222222211111111110000000000
533                                                             10987654321098765432109876543210
534                                                             x0100000000xxxxx101xxxxxxxxxxxx0
535                                                             ld1h.  */
536                                                          return 2611;
537                                                        }
538                                                    }
539                                                  else
540                                                    {
541                                                      if (((word >> 15) & 0x1) == 0)
542                                                        {
543                                                          /* 33222222222211111111110000000000
544                                                             10987654321098765432109876543210
545                                                             x0100000000xxxxx011xxxxxxxxxxxx0
546                                                             ld1d.  */
547                                                          return 2602;
548                                                        }
549                                                      else
550                                                        {
551                                                          /* 33222222222211111111110000000000
552                                                             10987654321098765432109876543210
553                                                             x0100000000xxxxx111xxxxxxxxxxxx0
554                                                             ld1d.  */
555                                                          return 2603;
556                                                        }
557                                                    }
558                                                }
559                                            }
560                                          else
561                                            {
562                                              if (((word >> 13) & 0x1) == 0)
563                                                {
564                                                  if (((word >> 14) & 0x1) == 0)
565                                                    {
566                                                      if (((word >> 15) & 0x1) == 0)
567                                                        {
568                                                          /* 33222222222211111111110000000000
569                                                             10987654321098765432109876543210
570                                                             x0100000000xxxxx000xxxxxxxxxxxx1
571                                                             ldnt1b.  */
572                                                          return 2626;
573                                                        }
574                                                      else
575                                                        {
576                                                          /* 33222222222211111111110000000000
577                                                             10987654321098765432109876543210
578                                                             x0100000000xxxxx100xxxxxxxxxxxx1
579                                                             ldnt1b.  */
580                                                          return 2627;
581                                                        }
582                                                    }
583                                                  else
584                                                    {
585                                                      if (((word >> 15) & 0x1) == 0)
586                                                        {
587                                                          /* 33222222222211111111110000000000
588                                                             10987654321098765432109876543210
589                                                             x0100000000xxxxx010xxxxxxxxxxxx1
590                                                             ldnt1w.  */
591                                                          return 2650;
592                                                        }
593                                                      else
594                                                        {
595                                                          /* 33222222222211111111110000000000
596                                                             10987654321098765432109876543210
597                                                             x0100000000xxxxx110xxxxxxxxxxxx1
598                                                             ldnt1w.  */
599                                                          return 2651;
600                                                        }
601                                                    }
602                                                }
603                                              else
604                                                {
605                                                  if (((word >> 14) & 0x1) == 0)
606                                                    {
607                                                      if (((word >> 15) & 0x1) == 0)
608                                                        {
609                                                          /* 33222222222211111111110000000000
610                                                             10987654321098765432109876543210
611                                                             x0100000000xxxxx001xxxxxxxxxxxx1
612                                                             ldnt1h.  */
613                                                          return 2642;
614                                                        }
615                                                      else
616                                                        {
617                                                          /* 33222222222211111111110000000000
618                                                             10987654321098765432109876543210
619                                                             x0100000000xxxxx101xxxxxxxxxxxx1
620                                                             ldnt1h.  */
621                                                          return 2643;
622                                                        }
623                                                    }
624                                                  else
625                                                    {
626                                                      if (((word >> 15) & 0x1) == 0)
627                                                        {
628                                                          /* 33222222222211111111110000000000
629                                                             10987654321098765432109876543210
630                                                             x0100000000xxxxx011xxxxxxxxxxxx1
631                                                             ldnt1d.  */
632                                                          return 2634;
633                                                        }
634                                                      else
635                                                        {
636                                                          /* 33222222222211111111110000000000
637                                                             10987654321098765432109876543210
638                                                             x0100000000xxxxx111xxxxxxxxxxxx1
639                                                             ldnt1d.  */
640                                                          return 2635;
641                                                        }
642                                                    }
643                                                }
644                                            }
645                                        }
646                                      else
647                                        {
648                                          /* 33222222222211111111110000000000
649                                             10987654321098765432109876543210
650                                             x1100000000xxxxxxxxxxxxxxxxxxxxx
651                                             ld1b.  */
652                                          return 2430;
653                                        }
654                                    }
655                                  else
656                                    {
657                                      if (((word >> 4) & 0x1) == 0)
658                                        {
659                                          if (((word >> 30) & 0x1) == 0)
660                                            {
661                                              if (((word >> 3) & 0x1) == 0)
662                                                {
663                                                  /* 33222222222211111111110000000000
664                                                     10987654321098765432109876543210
665                                                     x0100000100xxxxxxxxxxxxxxxx00xxx
666                                                     smopa.  */
667                                                  return 2409;
668                                                }
669                                              else
670                                                {
671                                                  /* 33222222222211111111110000000000
672                                                     10987654321098765432109876543210
673                                                     x0100000100xxxxxxxxxxxxxxxx01xxx
674                                                     smopa.  */
675                                                  return 2740;
676                                                }
677                                            }
678                                          else
679                                            {
680                                              /* 33222222222211111111110000000000
681                                                 10987654321098765432109876543210
682                                                 x1100000100xxxxxxxxxxxxxxxx0xxxx
683                                                 ld1w.  */
684                                              return 2432;
685                                            }
686                                        }
687                                      else
688                                        {
689                                          if (((word >> 3) & 0x1) == 0)
690                                            {
691                                              /* 33222222222211111111110000000000
692                                                 10987654321098765432109876543210
693                                                 xx100000100xxxxxxxxxxxxxxxx10xxx
694                                                 smops.  */
695                                              return 2411;
696                                            }
697                                          else
698                                            {
699                                              /* 33222222222211111111110000000000
700                                                 10987654321098765432109876543210
701                                                 xx100000100xxxxxxxxxxxxxxxx11xxx
702                                                 smops.  */
703                                              return 2741;
704                                            }
705                                        }
706                                    }
707                                }
708                              else
709                                {
710                                  if (((word >> 23) & 0x1) == 0)
711                                    {
712                                      if (((word >> 30) & 0x1) == 0)
713                                        {
714                                          if (((word >> 0) & 0x1) == 0)
715                                            {
716                                              if (((word >> 13) & 0x1) == 0)
717                                                {
718                                                  if (((word >> 14) & 0x1) == 0)
719                                                    {
720                                                      if (((word >> 15) & 0x1) == 0)
721                                                        {
722                                                          /* 33222222222211111111110000000000
723                                                             10987654321098765432109876543210
724                                                             x0100000010xxxxx000xxxxxxxxxxxx0
725                                                             ld1b.  */
726                                                          return 2590;
727                                                        }
728                                                      else
729                                                        {
730                                                          /* 33222222222211111111110000000000
731                                                             10987654321098765432109876543210
732                                                             x0100000010xxxxx100xxxxxxxxxxxx0
733                                                             ld1b.  */
734                                                          return 2591;
735                                                        }
736                                                    }
737                                                  else
738                                                    {
739                                                      if (((word >> 15) & 0x1) == 0)
740                                                        {
741                                                          /* 33222222222211111111110000000000
742                                                             10987654321098765432109876543210
743                                                             x0100000010xxxxx010xxxxxxxxxxxx0
744                                                             ld1w.  */
745                                                          return 2614;
746                                                        }
747                                                      else
748                                                        {
749                                                          /* 33222222222211111111110000000000
750                                                             10987654321098765432109876543210
751                                                             x0100000010xxxxx110xxxxxxxxxxxx0
752                                                             ld1w.  */
753                                                          return 2615;
754                                                        }
755                                                    }
756                                                }
757                                              else
758                                                {
759                                                  if (((word >> 14) & 0x1) == 0)
760                                                    {
761                                                      if (((word >> 15) & 0x1) == 0)
762                                                        {
763                                                          /* 33222222222211111111110000000000
764                                                             10987654321098765432109876543210
765                                                             x0100000010xxxxx001xxxxxxxxxxxx0
766                                                             ld1h.  */
767                                                          return 2606;
768                                                        }
769                                                      else
770                                                        {
771                                                          /* 33222222222211111111110000000000
772                                                             10987654321098765432109876543210
773                                                             x0100000010xxxxx101xxxxxxxxxxxx0
774                                                             ld1h.  */
775                                                          return 2607;
776                                                        }
777                                                    }
778                                                  else
779                                                    {
780                                                      if (((word >> 15) & 0x1) == 0)
781                                                        {
782                                                          /* 33222222222211111111110000000000
783                                                             10987654321098765432109876543210
784                                                             x0100000010xxxxx011xxxxxxxxxxxx0
785                                                             ld1d.  */
786                                                          return 2598;
787                                                        }
788                                                      else
789                                                        {
790                                                          /* 33222222222211111111110000000000
791                                                             10987654321098765432109876543210
792                                                             x0100000010xxxxx111xxxxxxxxxxxx0
793                                                             ld1d.  */
794                                                          return 2599;
795                                                        }
796                                                    }
797                                                }
798                                            }
799                                          else
800                                            {
801                                              if (((word >> 13) & 0x1) == 0)
802                                                {
803                                                  if (((word >> 14) & 0x1) == 0)
804                                                    {
805                                                      if (((word >> 15) & 0x1) == 0)
806                                                        {
807                                                          /* 33222222222211111111110000000000
808                                                             10987654321098765432109876543210
809                                                             x0100000010xxxxx000xxxxxxxxxxxx1
810                                                             ldnt1b.  */
811                                                          return 2622;
812                                                        }
813                                                      else
814                                                        {
815                                                          /* 33222222222211111111110000000000
816                                                             10987654321098765432109876543210
817                                                             x0100000010xxxxx100xxxxxxxxxxxx1
818                                                             ldnt1b.  */
819                                                          return 2623;
820                                                        }
821                                                    }
822                                                  else
823                                                    {
824                                                      if (((word >> 15) & 0x1) == 0)
825                                                        {
826                                                          /* 33222222222211111111110000000000
827                                                             10987654321098765432109876543210
828                                                             x0100000010xxxxx010xxxxxxxxxxxx1
829                                                             ldnt1w.  */
830                                                          return 2646;
831                                                        }
832                                                      else
833                                                        {
834                                                          /* 33222222222211111111110000000000
835                                                             10987654321098765432109876543210
836                                                             x0100000010xxxxx110xxxxxxxxxxxx1
837                                                             ldnt1w.  */
838                                                          return 2647;
839                                                        }
840                                                    }
841                                                }
842                                              else
843                                                {
844                                                  if (((word >> 14) & 0x1) == 0)
845                                                    {
846                                                      if (((word >> 15) & 0x1) == 0)
847                                                        {
848                                                          /* 33222222222211111111110000000000
849                                                             10987654321098765432109876543210
850                                                             x0100000010xxxxx001xxxxxxxxxxxx1
851                                                             ldnt1h.  */
852                                                          return 2638;
853                                                        }
854                                                      else
855                                                        {
856                                                          /* 33222222222211111111110000000000
857                                                             10987654321098765432109876543210
858                                                             x0100000010xxxxx101xxxxxxxxxxxx1
859                                                             ldnt1h.  */
860                                                          return 2639;
861                                                        }
862                                                    }
863                                                  else
864                                                    {
865                                                      if (((word >> 15) & 0x1) == 0)
866                                                        {
867                                                          /* 33222222222211111111110000000000
868                                                             10987654321098765432109876543210
869                                                             x0100000010xxxxx011xxxxxxxxxxxx1
870                                                             ldnt1d.  */
871                                                          return 2630;
872                                                        }
873                                                      else
874                                                        {
875                                                          /* 33222222222211111111110000000000
876                                                             10987654321098765432109876543210
877                                                             x0100000010xxxxx111xxxxxxxxxxxx1
878                                                             ldnt1d.  */
879                                                          return 2631;
880                                                        }
881                                                    }
882                                                }
883                                            }
884                                        }
885                                      else
886                                        {
887                                          /* 33222222222211111111110000000000
888                                             10987654321098765432109876543210
889                                             x1100000010xxxxxxxxxxxxxxxxxxxxx
890                                             ld1h.  */
891                                          return 2431;
892                                        }
893                                    }
894                                  else
895                                    {
896                                      if (((word >> 4) & 0x1) == 0)
897                                        {
898                                          if (((word >> 30) & 0x1) == 0)
899                                            {
900                                              /* 33222222222211111111110000000000
901                                                 10987654321098765432109876543210
902                                                 x0100000110xxxxxxxxxxxxxxxx0xxxx
903                                                 smopa.  */
904                                              return 2410;
905                                            }
906                                          else
907                                            {
908                                              /* 33222222222211111111110000000000
909                                                 10987654321098765432109876543210
910                                                 x1100000110xxxxxxxxxxxxxxxx0xxxx
911                                                 ld1d.  */
912                                              return 2433;
913                                            }
914                                        }
915                                      else
916                                        {
917                                          /* 33222222222211111111110000000000
918                                             10987654321098765432109876543210
919                                             xx100000110xxxxxxxxxxxxxxxx1xxxx
920                                             smops.  */
921                                          return 2412;
922                                        }
923                                    }
924                                }
925                            }
926                        }
927                      else
928                        {
929                          if (((word >> 22) & 0x1) == 0)
930                            {
931                              if (((word >> 23) & 0x1) == 0)
932                                {
933                                  if (((word >> 30) & 0x1) == 0)
934                                    {
935                                      if (((word >> 0) & 0x1) == 0)
936                                        {
937                                          if (((word >> 13) & 0x1) == 0)
938                                            {
939                                              if (((word >> 14) & 0x1) == 0)
940                                                {
941                                                  if (((word >> 15) & 0x1) == 0)
942                                                    {
943                                                      /* 33222222222211111111110000000000
944                                                         10987654321098765432109876543210
945                                                         x0x00000001xxxxx000xxxxxxxxxxxx0
946                                                         st1b.  */
947                                                      return 2766;
948                                                    }
949                                                  else
950                                                    {
951                                                      /* 33222222222211111111110000000000
952                                                         10987654321098765432109876543210
953                                                         x0x00000001xxxxx100xxxxxxxxxxxx0
954                                                         st1b.  */
955                                                      return 2767;
956                                                    }
957                                                }
958                                              else
959                                                {
960                                                  if (((word >> 15) & 0x1) == 0)
961                                                    {
962                                                      /* 33222222222211111111110000000000
963                                                         10987654321098765432109876543210
964                                                         x0x00000001xxxxx010xxxxxxxxxxxx0
965                                                         st1w.  */
966                                                      return 2790;
967                                                    }
968                                                  else
969                                                    {
970                                                      /* 33222222222211111111110000000000
971                                                         10987654321098765432109876543210
972                                                         x0x00000001xxxxx110xxxxxxxxxxxx0
973                                                         st1w.  */
974                                                      return 2791;
975                                                    }
976                                                }
977                                            }
978                                          else
979                                            {
980                                              if (((word >> 14) & 0x1) == 0)
981                                                {
982                                                  if (((word >> 15) & 0x1) == 0)
983                                                    {
984                                                      /* 33222222222211111111110000000000
985                                                         10987654321098765432109876543210
986                                                         x0x00000001xxxxx001xxxxxxxxxxxx0
987                                                         st1h.  */
988                                                      return 2782;
989                                                    }
990                                                  else
991                                                    {
992                                                      /* 33222222222211111111110000000000
993                                                         10987654321098765432109876543210
994                                                         x0x00000001xxxxx101xxxxxxxxxxxx0
995                                                         st1h.  */
996                                                      return 2783;
997                                                    }
998                                                }
999                                              else
1000                                                {
1001                                                  if (((word >> 15) & 0x1) == 0)
1002                                                    {
1003                                                      /* 33222222222211111111110000000000
1004                                                         10987654321098765432109876543210
1005                                                         x0x00000001xxxxx011xxxxxxxxxxxx0
1006                                                         st1d.  */
1007                                                      return 2774;
1008                                                    }
1009                                                  else
1010                                                    {
1011                                                      /* 33222222222211111111110000000000
1012                                                         10987654321098765432109876543210
1013                                                         x0x00000001xxxxx111xxxxxxxxxxxx0
1014                                                         st1d.  */
1015                                                      return 2775;
1016                                                    }
1017                                                }
1018                                            }
1019                                        }
1020                                      else
1021                                        {
1022                                          if (((word >> 13) & 0x1) == 0)
1023                                            {
1024                                              if (((word >> 14) & 0x1) == 0)
1025                                                {
1026                                                  if (((word >> 15) & 0x1) == 0)
1027                                                    {
1028                                                      /* 33222222222211111111110000000000
1029                                                         10987654321098765432109876543210
1030                                                         x0x00000001xxxxx000xxxxxxxxxxxx1
1031                                                         stnt1b.  */
1032                                                      return 2798;
1033                                                    }
1034                                                  else
1035                                                    {
1036                                                      /* 33222222222211111111110000000000
1037                                                         10987654321098765432109876543210
1038                                                         x0x00000001xxxxx100xxxxxxxxxxxx1
1039                                                         stnt1b.  */
1040                                                      return 2799;
1041                                                    }
1042                                                }
1043                                              else
1044                                                {
1045                                                  if (((word >> 15) & 0x1) == 0)
1046                                                    {
1047                                                      /* 33222222222211111111110000000000
1048                                                         10987654321098765432109876543210
1049                                                         x0x00000001xxxxx010xxxxxxxxxxxx1
1050                                                         stnt1w.  */
1051                                                      return 2822;
1052                                                    }
1053                                                  else
1054                                                    {
1055                                                      /* 33222222222211111111110000000000
1056                                                         10987654321098765432109876543210
1057                                                         x0x00000001xxxxx110xxxxxxxxxxxx1
1058                                                         stnt1w.  */
1059                                                      return 2823;
1060                                                    }
1061                                                }
1062                                            }
1063                                          else
1064                                            {
1065                                              if (((word >> 14) & 0x1) == 0)
1066                                                {
1067                                                  if (((word >> 15) & 0x1) == 0)
1068                                                    {
1069                                                      /* 33222222222211111111110000000000
1070                                                         10987654321098765432109876543210
1071                                                         x0x00000001xxxxx001xxxxxxxxxxxx1
1072                                                         stnt1h.  */
1073                                                      return 2814;
1074                                                    }
1075                                                  else
1076                                                    {
1077                                                      /* 33222222222211111111110000000000
1078                                                         10987654321098765432109876543210
1079                                                         x0x00000001xxxxx101xxxxxxxxxxxx1
1080                                                         stnt1h.  */
1081                                                      return 2815;
1082                                                    }
1083                                                }
1084                                              else
1085                                                {
1086                                                  if (((word >> 15) & 0x1) == 0)
1087                                                    {
1088                                                      /* 33222222222211111111110000000000
1089                                                         10987654321098765432109876543210
1090                                                         x0x00000001xxxxx011xxxxxxxxxxxx1
1091                                                         stnt1d.  */
1092                                                      return 2806;
1093                                                    }
1094                                                  else
1095                                                    {
1096                                                      /* 33222222222211111111110000000000
1097                                                         10987654321098765432109876543210
1098                                                         x0x00000001xxxxx111xxxxxxxxxxxx1
1099                                                         stnt1d.  */
1100                                                      return 2807;
1101                                                    }
1102                                                }
1103                                            }
1104                                        }
1105                                    }
1106                                  else
1107                                    {
1108                                      /* 33222222222211111111110000000000
1109                                         10987654321098765432109876543210
1110                                         x1x00000001xxxxxxxxxxxxxxxxxxxxx
1111                                         st1b.  */
1112                                      return 2440;
1113                                    }
1114                                }
1115                              else
1116                                {
1117                                  if (((word >> 4) & 0x1) == 0)
1118                                    {
1119                                      if (((word >> 30) & 0x1) == 0)
1120                                        {
1121                                          /* 33222222222211111111110000000000
1122                                             10987654321098765432109876543210
1123                                             x0x00000101xxxxxxxxxxxxxxxx0xxxx
1124                                             sumopa.  */
1125                                          return 2413;
1126                                        }
1127                                      else
1128                                        {
1129                                          /* 33222222222211111111110000000000
1130                                             10987654321098765432109876543210
1131                                             x1x00000101xxxxxxxxxxxxxxxx0xxxx
1132                                             st1w.  */
1133                                          return 2442;
1134                                        }
1135                                    }
1136                                  else
1137                                    {
1138                                      /* 33222222222211111111110000000000
1139                                         10987654321098765432109876543210
1140                                         xxx00000101xxxxxxxxxxxxxxxx1xxxx
1141                                         sumops.  */
1142                                      return 2415;
1143                                    }
1144                                }
1145                            }
1146                          else
1147                            {
1148                              if (((word >> 23) & 0x1) == 0)
1149                                {
1150                                  if (((word >> 30) & 0x1) == 0)
1151                                    {
1152                                      if (((word >> 0) & 0x1) == 0)
1153                                        {
1154                                          if (((word >> 13) & 0x1) == 0)
1155                                            {
1156                                              if (((word >> 14) & 0x1) == 0)
1157                                                {
1158                                                  if (((word >> 15) & 0x1) == 0)
1159                                                    {
1160                                                      /* 33222222222211111111110000000000
1161                                                         10987654321098765432109876543210
1162                                                         x0x00000011xxxxx000xxxxxxxxxxxx0
1163                                                         st1b.  */
1164                                                      return 2762;
1165                                                    }
1166                                                  else
1167                                                    {
1168                                                      /* 33222222222211111111110000000000
1169                                                         10987654321098765432109876543210
1170                                                         x0x00000011xxxxx100xxxxxxxxxxxx0
1171                                                         st1b.  */
1172                                                      return 2763;
1173                                                    }
1174                                                }
1175                                              else
1176                                                {
1177                                                  if (((word >> 15) & 0x1) == 0)
1178                                                    {
1179                                                      /* 33222222222211111111110000000000
1180                                                         10987654321098765432109876543210
1181                                                         x0x00000011xxxxx010xxxxxxxxxxxx0
1182                                                         st1w.  */
1183                                                      return 2786;
1184                                                    }
1185                                                  else
1186                                                    {
1187                                                      /* 33222222222211111111110000000000
1188                                                         10987654321098765432109876543210
1189                                                         x0x00000011xxxxx110xxxxxxxxxxxx0
1190                                                         st1w.  */
1191                                                      return 2787;
1192                                                    }
1193                                                }
1194                                            }
1195                                          else
1196                                            {
1197                                              if (((word >> 14) & 0x1) == 0)
1198                                                {
1199                                                  if (((word >> 15) & 0x1) == 0)
1200                                                    {
1201                                                      /* 33222222222211111111110000000000
1202                                                         10987654321098765432109876543210
1203                                                         x0x00000011xxxxx001xxxxxxxxxxxx0
1204                                                         st1h.  */
1205                                                      return 2778;
1206                                                    }
1207                                                  else
1208                                                    {
1209                                                      /* 33222222222211111111110000000000
1210                                                         10987654321098765432109876543210
1211                                                         x0x00000011xxxxx101xxxxxxxxxxxx0
1212                                                         st1h.  */
1213                                                      return 2779;
1214                                                    }
1215                                                }
1216                                              else
1217                                                {
1218                                                  if (((word >> 15) & 0x1) == 0)
1219                                                    {
1220                                                      /* 33222222222211111111110000000000
1221                                                         10987654321098765432109876543210
1222                                                         x0x00000011xxxxx011xxxxxxxxxxxx0
1223                                                         st1d.  */
1224                                                      return 2770;
1225                                                    }
1226                                                  else
1227                                                    {
1228                                                      /* 33222222222211111111110000000000
1229                                                         10987654321098765432109876543210
1230                                                         x0x00000011xxxxx111xxxxxxxxxxxx0
1231                                                         st1d.  */
1232                                                      return 2771;
1233                                                    }
1234                                                }
1235                                            }
1236                                        }
1237                                      else
1238                                        {
1239                                          if (((word >> 13) & 0x1) == 0)
1240                                            {
1241                                              if (((word >> 14) & 0x1) == 0)
1242                                                {
1243                                                  if (((word >> 15) & 0x1) == 0)
1244                                                    {
1245                                                      /* 33222222222211111111110000000000
1246                                                         10987654321098765432109876543210
1247                                                         x0x00000011xxxxx000xxxxxxxxxxxx1
1248                                                         stnt1b.  */
1249                                                      return 2794;
1250                                                    }
1251                                                  else
1252                                                    {
1253                                                      /* 33222222222211111111110000000000
1254                                                         10987654321098765432109876543210
1255                                                         x0x00000011xxxxx100xxxxxxxxxxxx1
1256                                                         stnt1b.  */
1257                                                      return 2795;
1258                                                    }
1259                                                }
1260                                              else
1261                                                {
1262                                                  if (((word >> 15) & 0x1) == 0)
1263                                                    {
1264                                                      /* 33222222222211111111110000000000
1265                                                         10987654321098765432109876543210
1266                                                         x0x00000011xxxxx010xxxxxxxxxxxx1
1267                                                         stnt1w.  */
1268                                                      return 2818;
1269                                                    }
1270                                                  else
1271                                                    {
1272                                                      /* 33222222222211111111110000000000
1273                                                         10987654321098765432109876543210
1274                                                         x0x00000011xxxxx110xxxxxxxxxxxx1
1275                                                         stnt1w.  */
1276                                                      return 2819;
1277                                                    }
1278                                                }
1279                                            }
1280                                          else
1281                                            {
1282                                              if (((word >> 14) & 0x1) == 0)
1283                                                {
1284                                                  if (((word >> 15) & 0x1) == 0)
1285                                                    {
1286                                                      /* 33222222222211111111110000000000
1287                                                         10987654321098765432109876543210
1288                                                         x0x00000011xxxxx001xxxxxxxxxxxx1
1289                                                         stnt1h.  */
1290                                                      return 2810;
1291                                                    }
1292                                                  else
1293                                                    {
1294                                                      /* 33222222222211111111110000000000
1295                                                         10987654321098765432109876543210
1296                                                         x0x00000011xxxxx101xxxxxxxxxxxx1
1297                                                         stnt1h.  */
1298                                                      return 2811;
1299                                                    }
1300                                                }
1301                                              else
1302                                                {
1303                                                  if (((word >> 15) & 0x1) == 0)
1304                                                    {
1305                                                      /* 33222222222211111111110000000000
1306                                                         10987654321098765432109876543210
1307                                                         x0x00000011xxxxx011xxxxxxxxxxxx1
1308                                                         stnt1d.  */
1309                                                      return 2802;
1310                                                    }
1311                                                  else
1312                                                    {
1313                                                      /* 33222222222211111111110000000000
1314                                                         10987654321098765432109876543210
1315                                                         x0x00000011xxxxx111xxxxxxxxxxxx1
1316                                                         stnt1d.  */
1317                                                      return 2803;
1318                                                    }
1319                                                }
1320                                            }
1321                                        }
1322                                    }
1323                                  else
1324                                    {
1325                                      /* 33222222222211111111110000000000
1326                                         10987654321098765432109876543210
1327                                         x1x00000011xxxxxxxxxxxxxxxxxxxxx
1328                                         st1h.  */
1329                                      return 2441;
1330                                    }
1331                                }
1332                              else
1333                                {
1334                                  if (((word >> 4) & 0x1) == 0)
1335                                    {
1336                                      if (((word >> 30) & 0x1) == 0)
1337                                        {
1338                                          /* 33222222222211111111110000000000
1339                                             10987654321098765432109876543210
1340                                             x0x00000111xxxxxxxxxxxxxxxx0xxxx
1341                                             sumopa.  */
1342                                          return 2414;
1343                                        }
1344                                      else
1345                                        {
1346                                          /* 33222222222211111111110000000000
1347                                             10987654321098765432109876543210
1348                                             x1x00000111xxxxxxxxxxxxxxxx0xxxx
1349                                             st1d.  */
1350                                          return 2443;
1351                                        }
1352                                    }
1353                                  else
1354                                    {
1355                                      /* 33222222222211111111110000000000
1356                                         10987654321098765432109876543210
1357                                         xxx00000111xxxxxxxxxxxxxxxx1xxxx
1358                                         sumops.  */
1359                                      return 2416;
1360                                    }
1361                                }
1362                            }
1363                        }
1364                    }
1365                  else
1366                    {
1367                      if (((word >> 31) & 0x1) == 0)
1368                        {
1369                          /* 33222222222211111111110000000000
1370                             10987654321098765432109876543210
1371                             0xx10000xxxxxxxxxxxxxxxxxxxxxxxx
1372                             adr.  */
1373                          return 1211;
1374                        }
1375                      else
1376                        {
1377                          /* 33222222222211111111110000000000
1378                             10987654321098765432109876543210
1379                             1xx10000xxxxxxxxxxxxxxxxxxxxxxxx
1380                             adrp.  */
1381                          return 1212;
1382                        }
1383                    }
1384                }
1385              else
1386                {
1387                  if (((word >> 28) & 0x1) == 0)
1388                    {
1389                      if (((word >> 21) & 0x1) == 0)
1390                        {
1391                          if (((word >> 22) & 0x1) == 0)
1392                            {
1393                              if (((word >> 23) & 0x1) == 0)
1394                                {
1395                                  if (((word >> 29) & 0x1) == 0)
1396                                    {
1397                                      if (((word >> 3) & 0x1) == 0)
1398                                        {
1399                                          if (((word >> 4) & 0x1) == 0)
1400                                            {
1401                                              if (((word >> 20) & 0x1) == 0)
1402                                                {
1403                                                  if (((word >> 2) & 0x1) == 0)
1404                                                    {
1405                                                      /* 33222222222211111111110000000000
1406                                                         10987654321098765432109876543210
1407                                                         xx0000010000xxxxxxxxxxxxxxx000xx
1408                                                         smlall.  */
1409                                                      return 2716;
1410                                                    }
1411                                                  else
1412                                                    {
1413                                                      /* 33222222222211111111110000000000
1414                                                         10987654321098765432109876543210
1415                                                         xx0000010000xxxxxxxxxxxxxxx001xx
1416                                                         usmlall.  */
1417                                                      return 2921;
1418                                                    }
1419                                                }
1420                                              else
1421                                                {
1422                                                  if (((word >> 5) & 0x1) == 0)
1423                                                    {
1424                                                      if (((word >> 15) & 0x1) == 0)
1425                                                        {
1426                                                          /* 33222222222211111111110000000000
1427                                                             10987654321098765432109876543210
1428                                                             xx0000010001xxxx0xxxxxxxxx000xxx
1429                                                             smlall.  */
1430                                                          return 2717;
1431                                                        }
1432                                                      else
1433                                                        {
1434                                                          /* 33222222222211111111110000000000
1435                                                             10987654321098765432109876543210
1436                                                             xx0000010001xxxx1xxxxxxxxx000xxx
1437                                                             smlall.  */
1438                                                          return 2718;
1439                                                        }
1440                                                    }
1441                                                  else
1442                                                    {
1443                                                      if (((word >> 15) & 0x1) == 0)
1444                                                        {
1445                                                          /* 33222222222211111111110000000000
1446                                                             10987654321098765432109876543210
1447                                                             xx0000010001xxxx0xxxxxxxxx100xxx
1448                                                             usmlall.  */
1449                                                          return 2922;
1450                                                        }
1451                                                      else
1452                                                        {
1453                                                          /* 33222222222211111111110000000000
1454                                                             10987654321098765432109876543210
1455                                                             xx0000010001xxxx1xxxxxxxxx100xxx
1456                                                             usmlall.  */
1457                                                          return 2923;
1458                                                        }
1459                                                    }
1460                                                }
1461                                            }
1462                                          else
1463                                            {
1464                                              if (((word >> 20) & 0x1) == 0)
1465                                                {
1466                                                  if (((word >> 2) & 0x1) == 0)
1467                                                    {
1468                                                      /* 33222222222211111111110000000000
1469                                                         10987654321098765432109876543210
1470                                                         xx0000010000xxxxxxxxxxxxxxx100xx
1471                                                         umlall.  */
1472                                                      return 2879;
1473                                                    }
1474                                                  else
1475                                                    {
1476                                                      /* 33222222222211111111110000000000
1477                                                         10987654321098765432109876543210
1478                                                         xx0000010000xxxxxxxxxxxxxxx101xx
1479                                                         sumlall.  */
1480                                                      return 2837;
1481                                                    }
1482                                                }
1483                                              else
1484                                                {
1485                                                  if (((word >> 5) & 0x1) == 0)
1486                                                    {
1487                                                      if (((word >> 15) & 0x1) == 0)
1488                                                        {
1489                                                          /* 33222222222211111111110000000000
1490                                                             10987654321098765432109876543210
1491                                                             xx0000010001xxxx0xxxxxxxxx010xxx
1492                                                             umlall.  */
1493                                                          return 2880;
1494                                                        }
1495                                                      else
1496                                                        {
1497                                                          /* 33222222222211111111110000000000
1498                                                             10987654321098765432109876543210
1499                                                             xx0000010001xxxx1xxxxxxxxx010xxx
1500                                                             umlall.  */
1501                                                          return 2881;
1502                                                        }
1503                                                    }
1504                                                  else
1505                                                    {
1506                                                      if (((word >> 15) & 0x1) == 0)
1507                                                        {
1508                                                          /* 33222222222211111111110000000000
1509                                                             10987654321098765432109876543210
1510                                                             xx0000010001xxxx0xxxxxxxxx110xxx
1511                                                             sumlall.  */
1512                                                          return 2838;
1513                                                        }
1514                                                      else
1515                                                        {
1516                                                          /* 33222222222211111111110000000000
1517                                                             10987654321098765432109876543210
1518                                                             xx0000010001xxxx1xxxxxxxxx110xxx
1519                                                             sumlall.  */
1520                                                          return 2839;
1521                                                        }
1522                                                    }
1523                                                }
1524                                            }
1525                                        }
1526                                      else
1527                                        {
1528                                          if (((word >> 4) & 0x1) == 0)
1529                                            {
1530                                              if (((word >> 20) & 0x1) == 0)
1531                                                {
1532                                                  /* 33222222222211111111110000000000
1533                                                     10987654321098765432109876543210
1534                                                     xx0000010000xxxxxxxxxxxxxxx01xxx
1535                                                     smlsll.  */
1536                                                  return 2732;
1537                                                }
1538                                              else
1539                                                {
1540                                                  if (((word >> 15) & 0x1) == 0)
1541                                                    {
1542                                                      /* 33222222222211111111110000000000
1543                                                         10987654321098765432109876543210
1544                                                         xx0000010001xxxx0xxxxxxxxxx01xxx
1545                                                         smlsll.  */
1546                                                      return 2733;
1547                                                    }
1548                                                  else
1549                                                    {
1550                                                      /* 33222222222211111111110000000000
1551                                                         10987654321098765432109876543210
1552                                                         xx0000010001xxxx1xxxxxxxxxx01xxx
1553                                                         smlsll.  */
1554                                                      return 2734;
1555                                                    }
1556                                                }
1557                                            }
1558                                          else
1559                                            {
1560                                              if (((word >> 20) & 0x1) == 0)
1561                                                {
1562                                                  /* 33222222222211111111110000000000
1563                                                     10987654321098765432109876543210
1564                                                     xx0000010000xxxxxxxxxxxxxxx11xxx
1565                                                     umlsll.  */
1566                                                  return 2895;
1567                                                }
1568                                              else
1569                                                {
1570                                                  if (((word >> 15) & 0x1) == 0)
1571                                                    {
1572                                                      /* 33222222222211111111110000000000
1573                                                         10987654321098765432109876543210
1574                                                         xx0000010001xxxx0xxxxxxxxxx11xxx
1575                                                         umlsll.  */
1576                                                      return 2896;
1577                                                    }
1578                                                  else
1579                                                    {
1580                                                      /* 33222222222211111111110000000000
1581                                                         10987654321098765432109876543210
1582                                                         xx0000010001xxxx1xxxxxxxxxx11xxx
1583                                                         umlsll.  */
1584                                                      return 2897;
1585                                                    }
1586                                                }
1587                                            }
1588                                        }
1589                                    }
1590                                  else
1591                                    {
1592                                      if (((word >> 15) & 0x1) == 0)
1593                                        {
1594                                          if (((word >> 30) & 0x1) == 0)
1595                                            {
1596                                              if (((word >> 3) & 0x1) == 0)
1597                                                {
1598                                                  if (((word >> 13) & 0x1) == 0)
1599                                                    {
1600                                                      if (((word >> 14) & 0x1) == 0)
1601                                                        {
1602                                                          /* 33222222222211111111110000000000
1603                                                             10987654321098765432109876543210
1604                                                             x0100001000xxxxx000xxxxxxxxx0xxx
1605                                                             ld1b.  */
1606                                                          return 2596;
1607                                                        }
1608                                                      else
1609                                                        {
1610                                                          /* 33222222222211111111110000000000
1611                                                             10987654321098765432109876543210
1612                                                             x0100001000xxxxx010xxxxxxxxx0xxx
1613                                                             ld1w.  */
1614                                                          return 2620;
1615                                                        }
1616                                                    }
1617                                                  else
1618                                                    {
1619                                                      if (((word >> 14) & 0x1) == 0)
1620                                                        {
1621                                                          /* 33222222222211111111110000000000
1622                                                             10987654321098765432109876543210
1623                                                             x0100001000xxxxx001xxxxxxxxx0xxx
1624                                                             ld1h.  */
1625                                                          return 2612;
1626                                                        }
1627                                                      else
1628                                                        {
1629                                                          /* 33222222222211111111110000000000
1630                                                             10987654321098765432109876543210
1631                                                             x0100001000xxxxx011xxxxxxxxx0xxx
1632                                                             ld1d.  */
1633                                                          return 2604;
1634                                                        }
1635                                                    }
1636                                                }
1637                                              else
1638                                                {
1639                                                  if (((word >> 13) & 0x1) == 0)
1640                                                    {
1641                                                      if (((word >> 14) & 0x1) == 0)
1642                                                        {
1643                                                          /* 33222222222211111111110000000000
1644                                                             10987654321098765432109876543210
1645                                                             x0100001000xxxxx000xxxxxxxxx1xxx
1646                                                             ldnt1b.  */
1647                                                          return 2628;
1648                                                        }
1649                                                      else
1650                                                        {
1651                                                          /* 33222222222211111111110000000000
1652                                                             10987654321098765432109876543210
1653                                                             x0100001000xxxxx010xxxxxxxxx1xxx
1654                                                             ldnt1w.  */
1655                                                          return 2652;
1656                                                        }
1657                                                    }
1658                                                  else
1659                                                    {
1660                                                      if (((word >> 14) & 0x1) == 0)
1661                                                        {
1662                                                          /* 33222222222211111111110000000000
1663                                                             10987654321098765432109876543210
1664                                                             x0100001000xxxxx001xxxxxxxxx1xxx
1665                                                             ldnt1h.  */
1666                                                          return 2644;
1667                                                        }
1668                                                      else
1669                                                        {
1670                                                          /* 33222222222211111111110000000000
1671                                                             10987654321098765432109876543210
1672                                                             x0100001000xxxxx011xxxxxxxxx1xxx
1673                                                             ldnt1d.  */
1674                                                          return 2636;
1675                                                        }
1676                                                    }
1677                                                }
1678                                            }
1679                                          else
1680                                            {
1681                                              /* 33222222222211111111110000000000
1682                                                 10987654321098765432109876543210
1683                                                 x1100001000xxxxx0xxxxxxxxxxxxxxx
1684                                                 ldr.  */
1685                                              return 2450;
1686                                            }
1687                                        }
1688                                      else
1689                                        {
1690                                          if (((word >> 3) & 0x1) == 0)
1691                                            {
1692                                              if (((word >> 13) & 0x1) == 0)
1693                                                {
1694                                                  if (((word >> 14) & 0x1) == 0)
1695                                                    {
1696                                                      if (((word >> 30) & 0x1) == 0)
1697                                                        {
1698                                                          /* 33222222222211111111110000000000
1699                                                             10987654321098765432109876543210
1700                                                             x0100001000xxxxx100xxxxxxxxx0xxx
1701                                                             ld1b.  */
1702                                                          return 2597;
1703                                                        }
1704                                                      else
1705                                                        {
1706                                                          /* 33222222222211111111110000000000
1707                                                             10987654321098765432109876543210
1708                                                             x1100001000xxxxx100xxxxxxxxx0xxx
1709                                                             ldr.  */
1710                                                          return 2654;
1711                                                        }
1712                                                    }
1713                                                  else
1714                                                    {
1715                                                      /* 33222222222211111111110000000000
1716                                                         10987654321098765432109876543210
1717                                                         xx100001000xxxxx110xxxxxxxxx0xxx
1718                                                         ld1w.  */
1719                                                      return 2621;
1720                                                    }
1721                                                }
1722                                              else
1723                                                {
1724                                                  if (((word >> 14) & 0x1) == 0)
1725                                                    {
1726                                                      /* 33222222222211111111110000000000
1727                                                         10987654321098765432109876543210
1728                                                         xx100001000xxxxx101xxxxxxxxx0xxx
1729                                                         ld1h.  */
1730                                                      return 2613;
1731                                                    }
1732                                                  else
1733                                                    {
1734                                                      /* 33222222222211111111110000000000
1735                                                         10987654321098765432109876543210
1736                                                         xx100001000xxxxx111xxxxxxxxx0xxx
1737                                                         ld1d.  */
1738                                                      return 2605;
1739                                                    }
1740                                                }
1741                                            }
1742                                          else
1743                                            {
1744                                              if (((word >> 13) & 0x1) == 0)
1745                                                {
1746                                                  if (((word >> 14) & 0x1) == 0)
1747                                                    {
1748                                                      /* 33222222222211111111110000000000
1749                                                         10987654321098765432109876543210
1750                                                         xx100001000xxxxx100xxxxxxxxx1xxx
1751                                                         ldnt1b.  */
1752                                                      return 2629;
1753                                                    }
1754                                                  else
1755                                                    {
1756                                                      /* 33222222222211111111110000000000
1757                                                         10987654321098765432109876543210
1758                                                         xx100001000xxxxx110xxxxxxxxx1xxx
1759                                                         ldnt1w.  */
1760                                                      return 2653;
1761                                                    }
1762                                                }
1763                                              else
1764                                                {
1765                                                  if (((word >> 14) & 0x1) == 0)
1766                                                    {
1767                                                      /* 33222222222211111111110000000000
1768                                                         10987654321098765432109876543210
1769                                                         xx100001000xxxxx101xxxxxxxxx1xxx
1770                                                         ldnt1h.  */
1771                                                      return 2645;
1772                                                    }
1773                                                  else
1774                                                    {
1775                                                      /* 33222222222211111111110000000000
1776                                                         10987654321098765432109876543210
1777                                                         xx100001000xxxxx111xxxxxxxxx1xxx
1778                                                         ldnt1d.  */
1779                                                      return 2637;
1780                                                    }
1781                                                }
1782                                            }
1783                                        }
1784                                    }
1785                                }
1786                              else
1787                                {
1788                                  if (((word >> 3) & 0x1) == 0)
1789                                    {
1790                                      if (((word >> 4) & 0x1) == 0)
1791                                        {
1792                                          if (((word >> 29) & 0x1) == 0)
1793                                            {
1794                                              if (((word >> 30) & 0x1) == 0)
1795                                                {
1796                                                  /* 33222222222211111111110000000000
1797                                                     10987654321098765432109876543210
1798                                                     x0000001100xxxxxxxxxxxxxxxx00xxx
1799                                                     bfmopa.  */
1800                                                  return 2400;
1801                                                }
1802                                              else
1803                                                {
1804                                                  if (((word >> 12) & 0x1) == 0)
1805                                                    {
1806                                                      if (((word >> 20) & 0x1) == 0)
1807                                                        {
1808                                                          /* 33222222222211111111110000000000
1809                                                             10987654321098765432109876543210
1810                                                             x10000011000xxxxxxx0xxxxxxx00xxx
1811                                                             smlall.  */
1812                                                          return 2953;
1813                                                        }
1814                                                      else
1815                                                        {
1816                                                          if (((word >> 15) & 0x1) == 0)
1817                                                            {
1818                                                              /* 33222222222211111111110000000000
1819                                                                 10987654321098765432109876543210
1820                                                                 x10000011001xxxx0xx0xxxxxxx00xxx
1821                                                                 smlall.  */
1822                                                              return 2954;
1823                                                            }
1824                                                          else
1825                                                            {
1826                                                              /* 33222222222211111111110000000000
1827                                                                 10987654321098765432109876543210
1828                                                                 x10000011001xxxx1xx0xxxxxxx00xxx
1829                                                                 smlall.  */
1830                                                              return 2955;
1831                                                            }
1832                                                        }
1833                                                    }
1834                                                  else
1835                                                    {
1836                                                      if (((word >> 20) & 0x1) == 0)
1837                                                        {
1838                                                          /* 33222222222211111111110000000000
1839                                                             10987654321098765432109876543210
1840                                                             x10000011000xxxxxxx1xxxxxxx00xxx
1841                                                             fmlal.  */
1842                                                          return 2557;
1843                                                        }
1844                                                      else
1845                                                        {
1846                                                          if (((word >> 15) & 0x1) == 0)
1847                                                            {
1848                                                              /* 33222222222211111111110000000000
1849                                                                 10987654321098765432109876543210
1850                                                                 x10000011001xxxx0xx1xxxxxxx00xxx
1851                                                                 fmlal.  */
1852                                                              return 2558;
1853                                                            }
1854                                                          else
1855                                                            {
1856                                                              /* 33222222222211111111110000000000
1857                                                                 10987654321098765432109876543210
1858                                                                 x10000011001xxxx1xx1xxxxxxx00xxx
1859                                                                 fmlal.  */
1860                                                              return 2559;
1861                                                            }
1862                                                        }
1863                                                    }
1864                                                }
1865                                            }
1866                                          else
1867                                            {
1868                                              /* 33222222222211111111110000000000
1869                                                 10987654321098765432109876543210
1870                                                 xx100001100xxxxxxxxxxxxxxxx00xxx
1871                                                 usmopa.  */
1872                                              return 2421;
1873                                            }
1874                                        }
1875                                      else
1876                                        {
1877                                          if (((word >> 29) & 0x1) == 0)
1878                                            {
1879                                              if (((word >> 30) & 0x1) == 0)
1880                                                {
1881                                                  /* 33222222222211111111110000000000
1882                                                     10987654321098765432109876543210
1883                                                     x0000001100xxxxxxxxxxxxxxxx10xxx
1884                                                     bfmops.  */
1885                                                  return 2401;
1886                                                }
1887                                              else
1888                                                {
1889                                                  if (((word >> 12) & 0x1) == 0)
1890                                                    {
1891                                                      if (((word >> 20) & 0x1) == 0)
1892                                                        {
1893                                                          /* 33222222222211111111110000000000
1894                                                             10987654321098765432109876543210
1895                                                             x10000011000xxxxxxx0xxxxxxx10xxx
1896                                                             umlall.  */
1897                                                          return 2962;
1898                                                        }
1899                                                      else
1900                                                        {
1901                                                          if (((word >> 15) & 0x1) == 0)
1902                                                            {
1903                                                              /* 33222222222211111111110000000000
1904                                                                 10987654321098765432109876543210
1905                                                                 x10000011001xxxx0xx0xxxxxxx10xxx
1906                                                                 umlall.  */
1907                                                              return 2963;
1908                                                            }
1909                                                          else
1910                                                            {
1911                                                              /* 33222222222211111111110000000000
1912                                                                 10987654321098765432109876543210
1913                                                                 x10000011001xxxx1xx0xxxxxxx10xxx
1914                                                                 umlall.  */
1915                                                              return 2964;
1916                                                            }
1917                                                        }
1918                                                    }
1919                                                  else
1920                                                    {
1921                                                      if (((word >> 20) & 0x1) == 0)
1922                                                        {
1923                                                          /* 33222222222211111111110000000000
1924                                                             10987654321098765432109876543210
1925                                                             x10000011000xxxxxxx1xxxxxxx10xxx
1926                                                             bfmlal.  */
1927                                                          return 2499;
1928                                                        }
1929                                                      else
1930                                                        {
1931                                                          if (((word >> 15) & 0x1) == 0)
1932                                                            {
1933                                                              /* 33222222222211111111110000000000
1934                                                                 10987654321098765432109876543210
1935                                                                 x10000011001xxxx0xx1xxxxxxx10xxx
1936                                                                 bfmlal.  */
1937                                                              return 2500;
1938                                                            }
1939                                                          else
1940                                                            {
1941                                                              /* 33222222222211111111110000000000
1942                                                                 10987654321098765432109876543210
1943                                                                 x10000011001xxxx1xx1xxxxxxx10xxx
1944                                                                 bfmlal.  */
1945                                                              return 2501;
1946                                                            }
1947                                                        }
1948                                                    }
1949                                                }
1950                                            }
1951                                          else
1952                                            {
1953                                              /* 33222222222211111111110000000000
1954                                                 10987654321098765432109876543210
1955                                                 xx100001100xxxxxxxxxxxxxxxx10xxx
1956                                                 usmops.  */
1957                                              return 2423;
1958                                            }
1959                                        }
1960                                    }
1961                                  else
1962                                    {
1963                                      if (((word >> 4) & 0x1) == 0)
1964                                        {
1965                                          if (((word >> 29) & 0x1) == 0)
1966                                            {
1967                                              if (((word >> 12) & 0x1) == 0)
1968                                                {
1969                                                  if (((word >> 20) & 0x1) == 0)
1970                                                    {
1971                                                      /* 33222222222211111111110000000000
1972                                                         10987654321098765432109876543210
1973                                                         xx0000011000xxxxxxx0xxxxxxx01xxx
1974                                                         smlsll.  */
1975                                                      return 2956;
1976                                                    }
1977                                                  else
1978                                                    {
1979                                                      if (((word >> 15) & 0x1) == 0)
1980                                                        {
1981                                                          /* 33222222222211111111110000000000
1982                                                             10987654321098765432109876543210
1983                                                             xx0000011001xxxx0xx0xxxxxxx01xxx
1984                                                             smlsll.  */
1985                                                          return 2957;
1986                                                        }
1987                                                      else
1988                                                        {
1989                                                          /* 33222222222211111111110000000000
1990                                                             10987654321098765432109876543210
1991                                                             xx0000011001xxxx1xx0xxxxxxx01xxx
1992                                                             smlsll.  */
1993                                                          return 2958;
1994                                                        }
1995                                                    }
1996                                                }
1997                                              else
1998                                                {
1999                                                  if (((word >> 20) & 0x1) == 0)
2000                                                    {
2001                                                      /* 33222222222211111111110000000000
2002                                                         10987654321098765432109876543210
2003                                                         xx0000011000xxxxxxx1xxxxxxx01xxx
2004                                                         fmlsl.  */
2005                                                      return 2571;
2006                                                    }
2007                                                  else
2008                                                    {
2009                                                      if (((word >> 15) & 0x1) == 0)
2010                                                        {
2011                                                          /* 33222222222211111111110000000000
2012                                                             10987654321098765432109876543210
2013                                                             xx0000011001xxxx0xx1xxxxxxx01xxx
2014                                                             fmlsl.  */
2015                                                          return 2572;
2016                                                        }
2017                                                      else
2018                                                        {
2019                                                          /* 33222222222211111111110000000000
2020                                                             10987654321098765432109876543210
2021                                                             xx0000011001xxxx1xx1xxxxxxx01xxx
2022                                                             fmlsl.  */
2023                                                          return 2573;
2024                                                        }
2025                                                    }
2026                                                }
2027                                            }
2028                                          else
2029                                            {
2030                                              /* 33222222222211111111110000000000
2031                                                 10987654321098765432109876543210
2032                                                 xx100001100xxxxxxxxxxxxxxxx01xxx
2033                                                 umopa.  */
2034                                              return 2903;
2035                                            }
2036                                        }
2037                                      else
2038                                        {
2039                                          if (((word >> 29) & 0x1) == 0)
2040                                            {
2041                                              if (((word >> 12) & 0x1) == 0)
2042                                                {
2043                                                  if (((word >> 20) & 0x1) == 0)
2044                                                    {
2045                                                      /* 33222222222211111111110000000000
2046                                                         10987654321098765432109876543210
2047                                                         xx0000011000xxxxxxx0xxxxxxx11xxx
2048                                                         umlsll.  */
2049                                                      return 2965;
2050                                                    }
2051                                                  else
2052                                                    {
2053                                                      if (((word >> 15) & 0x1) == 0)
2054                                                        {
2055                                                          /* 33222222222211111111110000000000
2056                                                             10987654321098765432109876543210
2057                                                             xx0000011001xxxx0xx0xxxxxxx11xxx
2058                                                             umlsll.  */
2059                                                          return 2966;
2060                                                        }
2061                                                      else
2062                                                        {
2063                                                          /* 33222222222211111111110000000000
2064                                                             10987654321098765432109876543210
2065                                                             xx0000011001xxxx1xx0xxxxxxx11xxx
2066                                                             umlsll.  */
2067                                                          return 2967;
2068                                                        }
2069                                                    }
2070                                                }
2071                                              else
2072                                                {
2073                                                  if (((word >> 20) & 0x1) == 0)
2074                                                    {
2075                                                      /* 33222222222211111111110000000000
2076                                                         10987654321098765432109876543210
2077                                                         xx0000011000xxxxxxx1xxxxxxx11xxx
2078                                                         bfmlsl.  */
2079                                                      return 2507;
2080                                                    }
2081                                                  else
2082                                                    {
2083                                                      if (((word >> 15) & 0x1) == 0)
2084                                                        {
2085                                                          /* 33222222222211111111110000000000
2086                                                             10987654321098765432109876543210
2087                                                             xx0000011001xxxx0xx1xxxxxxx11xxx
2088                                                             bfmlsl.  */
2089                                                          return 2508;
2090                                                        }
2091                                                      else
2092                                                        {
2093                                                          /* 33222222222211111111110000000000
2094                                                             10987654321098765432109876543210
2095                                                             xx0000011001xxxx1xx1xxxxxxx11xxx
2096                                                             bfmlsl.  */
2097                                                          return 2509;
2098                                                        }
2099                                                    }
2100                                                }
2101                                            }
2102                                          else
2103                                            {
2104                                              /* 33222222222211111111110000000000
2105                                                 10987654321098765432109876543210
2106                                                 xx100001100xxxxxxxxxxxxxxxx11xxx
2107                                                 umops.  */
2108                                              return 2904;
2109                                            }
2110                                        }
2111                                    }
2112                                }
2113                            }
2114                          else
2115                            {
2116                              if (((word >> 23) & 0x1) == 0)
2117                                {
2118                                  if (((word >> 3) & 0x1) == 0)
2119                                    {
2120                                      if (((word >> 15) & 0x1) == 0)
2121                                        {
2122                                          if (((word >> 20) & 0x1) == 0)
2123                                            {
2124                                              if (((word >> 13) & 0x1) == 0)
2125                                                {
2126                                                  if (((word >> 14) & 0x1) == 0)
2127                                                    {
2128                                                      /* 33222222222211111111110000000000
2129                                                         10987654321098765432109876543210
2130                                                         xxx000010100xxxx000xxxxxxxxx0xxx
2131                                                         ld1b.  */
2132                                                      return 2592;
2133                                                    }
2134                                                  else
2135                                                    {
2136                                                      /* 33222222222211111111110000000000
2137                                                         10987654321098765432109876543210
2138                                                         xxx000010100xxxx010xxxxxxxxx0xxx
2139                                                         ld1w.  */
2140                                                      return 2616;
2141                                                    }
2142                                                }
2143                                              else
2144                                                {
2145                                                  if (((word >> 14) & 0x1) == 0)
2146                                                    {
2147                                                      /* 33222222222211111111110000000000
2148                                                         10987654321098765432109876543210
2149                                                         xxx000010100xxxx001xxxxxxxxx0xxx
2150                                                         ld1h.  */
2151                                                      return 2608;
2152                                                    }
2153                                                  else
2154                                                    {
2155                                                      /* 33222222222211111111110000000000
2156                                                         10987654321098765432109876543210
2157                                                         xxx000010100xxxx011xxxxxxxxx0xxx
2158                                                         ld1d.  */
2159                                                      return 2600;
2160                                                    }
2161                                                }
2162                                            }
2163                                          else
2164                                            {
2165                                              if (((word >> 4) & 0x1) == 0)
2166                                                {
2167                                                  if (((word >> 5) & 0x1) == 0)
2168                                                    {
2169                                                      if (((word >> 12) & 0x1) == 0)
2170                                                        {
2171                                                          /* 33222222222211111111110000000000
2172                                                             10987654321098765432109876543210
2173                                                             xxx000010101xxxx0xx0xxxxxx000xxx
2174                                                             fmla.  */
2175                                                          return 2551;
2176                                                        }
2177                                                      else
2178                                                        {
2179                                                          /* 33222222222211111111110000000000
2180                                                             10987654321098765432109876543210
2181                                                             xxx000010101xxxx0xx1xxxxxx000xxx
2182                                                             sdot.  */
2183                                                          return 2686;
2184                                                        }
2185                                                    }
2186                                                  else
2187                                                    {
2188                                                      if (((word >> 12) & 0x1) == 0)
2189                                                        {
2190                                                          /* 33222222222211111111110000000000
2191                                                             10987654321098765432109876543210
2192                                                             xxx000010101xxxx0xx0xxxxxx100xxx
2193                                                             svdot.  */
2194                                                          return 2845;
2195                                                        }
2196                                                      else
2197                                                        {
2198                                                          /* 33222222222211111111110000000000
2199                                                             10987654321098765432109876543210
2200                                                             xxx000010101xxxx0xx1xxxxxx100xxx
2201                                                             sdot.  */
2202                                                          return 2692;
2203                                                        }
2204                                                    }
2205                                                }
2206                                              else
2207                                                {
2208                                                  if (((word >> 5) & 0x1) == 0)
2209                                                    {
2210                                                      if (((word >> 12) & 0x1) == 0)
2211                                                        {
2212                                                          /* 33222222222211111111110000000000
2213                                                             10987654321098765432109876543210
2214                                                             xxx000010101xxxx0xx0xxxxxx010xxx
2215                                                             fmls.  */
2216                                                          return 2565;
2217                                                        }
2218                                                      else
2219                                                        {
2220                                                          /* 33222222222211111111110000000000
2221                                                             10987654321098765432109876543210
2222                                                             xxx000010101xxxx0xx1xxxxxx010xxx
2223                                                             udot.  */
2224                                                          return 2851;
2225                                                        }
2226                                                    }
2227                                                  else
2228                                                    {
2229                                                      if (((word >> 12) & 0x1) == 0)
2230                                                        {
2231                                                          /* 33222222222211111111110000000000
2232                                                             10987654321098765432109876543210
2233                                                             xxx000010101xxxx0xx0xxxxxx110xxx
2234                                                             uvdot.  */
2235                                                          return 2932;
2236                                                        }
2237                                                      else
2238                                                        {
2239                                                          /* 33222222222211111111110000000000
2240                                                             10987654321098765432109876543210
2241                                                             xxx000010101xxxx0xx1xxxxxx110xxx
2242                                                             udot.  */
2243                                                          return 2857;
2244                                                        }
2245                                                    }
2246                                                }
2247                                            }
2248                                        }
2249                                      else
2250                                        {
2251                                          if (((word >> 20) & 0x1) == 0)
2252                                            {
2253                                              if (((word >> 13) & 0x1) == 0)
2254                                                {
2255                                                  if (((word >> 14) & 0x1) == 0)
2256                                                    {
2257                                                      /* 33222222222211111111110000000000
2258                                                         10987654321098765432109876543210
2259                                                         xxx000010100xxxx100xxxxxxxxx0xxx
2260                                                         ld1b.  */
2261                                                      return 2593;
2262                                                    }
2263                                                  else
2264                                                    {
2265                                                      /* 33222222222211111111110000000000
2266                                                         10987654321098765432109876543210
2267                                                         xxx000010100xxxx110xxxxxxxxx0xxx
2268                                                         ld1w.  */
2269                                                      return 2617;
2270                                                    }
2271                                                }
2272                                              else
2273                                                {
2274                                                  if (((word >> 14) & 0x1) == 0)
2275                                                    {
2276                                                      /* 33222222222211111111110000000000
2277                                                         10987654321098765432109876543210
2278                                                         xxx000010100xxxx101xxxxxxxxx0xxx
2279                                                         ld1h.  */
2280                                                      return 2609;
2281                                                    }
2282                                                  else
2283                                                    {
2284                                                      /* 33222222222211111111110000000000
2285                                                         10987654321098765432109876543210
2286                                                         xxx000010100xxxx111xxxxxxxxx0xxx
2287                                                         ld1d.  */
2288                                                      return 2601;
2289                                                    }
2290                                                }
2291                                            }
2292                                          else
2293                                            {
2294                                              if (((word >> 4) & 0x1) == 0)
2295                                                {
2296                                                  if (((word >> 5) & 0x1) == 0)
2297                                                    {
2298                                                      if (((word >> 12) & 0x1) == 0)
2299                                                        {
2300                                                          /* 33222222222211111111110000000000
2301                                                             10987654321098765432109876543210
2302                                                             xxx000010101xxxx1xx0xxxxxx000xxx
2303                                                             fmla.  */
2304                                                          return 2552;
2305                                                        }
2306                                                      else
2307                                                        {
2308                                                          /* 33222222222211111111110000000000
2309                                                             10987654321098765432109876543210
2310                                                             xxx000010101xxxx1xx1xxxxxx000xxx
2311                                                             sdot.  */
2312                                                          return 2687;
2313                                                        }
2314                                                    }
2315                                                  else
2316                                                    {
2317                                                      if (((word >> 12) & 0x1) == 0)
2318                                                        {
2319                                                          /* 33222222222211111111110000000000
2320                                                             10987654321098765432109876543210
2321                                                             xxx000010101xxxx1xx0xxxxxx100xxx
2322                                                             svdot.  */
2323                                                          return 2846;
2324                                                        }
2325                                                      else
2326                                                        {
2327                                                          /* 33222222222211111111110000000000
2328                                                             10987654321098765432109876543210
2329                                                             xxx000010101xxxx1xx1xxxxxx100xxx
2330                                                             sdot.  */
2331                                                          return 2693;
2332                                                        }
2333                                                    }
2334                                                }
2335                                              else
2336                                                {
2337                                                  if (((word >> 5) & 0x1) == 0)
2338                                                    {
2339                                                      if (((word >> 12) & 0x1) == 0)
2340                                                        {
2341                                                          /* 33222222222211111111110000000000
2342                                                             10987654321098765432109876543210
2343                                                             xxx000010101xxxx1xx0xxxxxx010xxx
2344                                                             fmls.  */
2345                                                          return 2566;
2346                                                        }
2347                                                      else
2348                                                        {
2349                                                          /* 33222222222211111111110000000000
2350                                                             10987654321098765432109876543210
2351                                                             xxx000010101xxxx1xx1xxxxxx010xxx
2352                                                             udot.  */
2353                                                          return 2852;
2354                                                        }
2355                                                    }
2356                                                  else
2357                                                    {
2358                                                      if (((word >> 12) & 0x1) == 0)
2359                                                        {
2360                                                          /* 33222222222211111111110000000000
2361                                                             10987654321098765432109876543210
2362                                                             xxx000010101xxxx1xx0xxxxxx110xxx
2363                                                             uvdot.  */
2364                                                          return 2933;
2365                                                        }
2366                                                      else
2367                                                        {
2368                                                          /* 33222222222211111111110000000000
2369                                                             10987654321098765432109876543210
2370                                                             xxx000010101xxxx1xx1xxxxxx110xxx
2371                                                             udot.  */
2372                                                          return 2858;
2373                                                        }
2374                                                    }
2375                                                }
2376                                            }
2377                                        }
2378                                    }
2379                                  else
2380                                    {
2381                                      if (((word >> 15) & 0x1) == 0)
2382                                        {
2383                                          if (((word >> 20) & 0x1) == 0)
2384                                            {
2385                                              if (((word >> 13) & 0x1) == 0)
2386                                                {
2387                                                  if (((word >> 14) & 0x1) == 0)
2388                                                    {
2389                                                      /* 33222222222211111111110000000000
2390                                                         10987654321098765432109876543210
2391                                                         xxx000010100xxxx000xxxxxxxxx1xxx
2392                                                         ldnt1b.  */
2393                                                      return 2624;
2394                                                    }
2395                                                  else
2396                                                    {
2397                                                      /* 33222222222211111111110000000000
2398                                                         10987654321098765432109876543210
2399                                                         xxx000010100xxxx010xxxxxxxxx1xxx
2400                                                         ldnt1w.  */
2401                                                      return 2648;
2402                                                    }
2403                                                }
2404                                              else
2405                                                {
2406                                                  if (((word >> 14) & 0x1) == 0)
2407                                                    {
2408                                                      /* 33222222222211111111110000000000
2409                                                         10987654321098765432109876543210
2410                                                         xxx000010100xxxx001xxxxxxxxx1xxx
2411                                                         ldnt1h.  */
2412                                                      return 2640;
2413                                                    }
2414                                                  else
2415                                                    {
2416                                                      /* 33222222222211111111110000000000
2417                                                         10987654321098765432109876543210
2418                                                         xxx000010100xxxx011xxxxxxxxx1xxx
2419                                                         ldnt1d.  */
2420                                                      return 2632;
2421                                                    }
2422                                                }
2423                                            }
2424                                          else
2425                                            {
2426                                              if (((word >> 4) & 0x1) == 0)
2427                                                {
2428                                                  if (((word >> 5) & 0x1) == 0)
2429                                                    {
2430                                                      if (((word >> 12) & 0x1) == 0)
2431                                                        {
2432                                                          /* 33222222222211111111110000000000
2433                                                             10987654321098765432109876543210
2434                                                             xxx000010101xxxx0xx0xxxxxx001xxx
2435                                                             fvdot.  */
2436                                                          return 2589;
2437                                                        }
2438                                                      else
2439                                                        {
2440                                                          /* 33222222222211111111110000000000
2441                                                             10987654321098765432109876543210
2442                                                             xxx000010101xxxx0xx1xxxxxx001xxx
2443                                                             fdot.  */
2444                                                          return 2529;
2445                                                        }
2446                                                    }
2447                                                  else
2448                                                    {
2449                                                      /* 33222222222211111111110000000000
2450                                                         10987654321098765432109876543210
2451                                                         xxx000010101xxxx0xxxxxxxxx101xxx
2452                                                         usdot.  */
2453                                                      return 2915;
2454                                                    }
2455                                                }
2456                                              else
2457                                                {
2458                                                  if (((word >> 5) & 0x1) == 0)
2459                                                    {
2460                                                      if (((word >> 12) & 0x1) == 0)
2461                                                        {
2462                                                          /* 33222222222211111111110000000000
2463                                                             10987654321098765432109876543210
2464                                                             xxx000010101xxxx0xx0xxxxxx011xxx
2465                                                             bfvdot.  */
2466                                                          return 2515;
2467                                                        }
2468                                                      else
2469                                                        {
2470                                                          /* 33222222222211111111110000000000
2471                                                             10987654321098765432109876543210
2472                                                             xxx000010101xxxx0xx1xxxxxx011xxx
2473                                                             bfdot.  */
2474                                                          return 2493;
2475                                                        }
2476                                                    }
2477                                                  else
2478                                                    {
2479                                                      /* 33222222222211111111110000000000
2480                                                         10987654321098765432109876543210
2481                                                         xxx000010101xxxx0xxxxxxxxx111xxx
2482                                                         sudot.  */
2483                                                      return 2833;
2484                                                    }
2485                                                }
2486                                            }
2487                                        }
2488                                      else
2489                                        {
2490                                          if (((word >> 20) & 0x1) == 0)
2491                                            {
2492                                              if (((word >> 13) & 0x1) == 0)
2493                                                {
2494                                                  if (((word >> 14) & 0x1) == 0)
2495                                                    {
2496                                                      /* 33222222222211111111110000000000
2497                                                         10987654321098765432109876543210
2498                                                         xxx000010100xxxx100xxxxxxxxx1xxx
2499                                                         ldnt1b.  */
2500                                                      return 2625;
2501                                                    }
2502                                                  else
2503                                                    {
2504                                                      /* 33222222222211111111110000000000
2505                                                         10987654321098765432109876543210
2506                                                         xxx000010100xxxx110xxxxxxxxx1xxx
2507                                                         ldnt1w.  */
2508                                                      return 2649;
2509                                                    }
2510                                                }
2511                                              else
2512                                                {
2513                                                  if (((word >> 14) & 0x1) == 0)
2514                                                    {
2515                                                      /* 33222222222211111111110000000000
2516                                                         10987654321098765432109876543210
2517                                                         xxx000010100xxxx101xxxxxxxxx1xxx
2518                                                         ldnt1h.  */
2519                                                      return 2641;
2520                                                    }
2521                                                  else
2522                                                    {
2523                                                      /* 33222222222211111111110000000000
2524                                                         10987654321098765432109876543210
2525                                                         xxx000010100xxxx111xxxxxxxxx1xxx
2526                                                         ldnt1d.  */
2527                                                      return 2633;
2528                                                    }
2529                                                }
2530                                            }
2531                                          else
2532                                            {
2533                                              if (((word >> 4) & 0x1) == 0)
2534                                                {
2535                                                  if (((word >> 5) & 0x1) == 0)
2536                                                    {
2537                                                      /* 33222222222211111111110000000000
2538                                                         10987654321098765432109876543210
2539                                                         xxx000010101xxxx1xxxxxxxxx001xxx
2540                                                         fdot.  */
2541                                                      return 2530;
2542                                                    }
2543                                                  else
2544                                                    {
2545                                                      if (((word >> 12) & 0x1) == 0)
2546                                                        {
2547                                                          /* 33222222222211111111110000000000
2548                                                             10987654321098765432109876543210
2549                                                             xxx000010101xxxx1xx0xxxxxx101xxx
2550                                                             usvdot.  */
2551                                                          return 2929;
2552                                                        }
2553                                                      else
2554                                                        {
2555                                                          /* 33222222222211111111110000000000
2556                                                             10987654321098765432109876543210
2557                                                             xxx000010101xxxx1xx1xxxxxx101xxx
2558                                                             usdot.  */
2559                                                          return 2916;
2560                                                        }
2561                                                    }
2562                                                }
2563                                              else
2564                                                {
2565                                                  if (((word >> 5) & 0x1) == 0)
2566                                                    {
2567                                                      /* 33222222222211111111110000000000
2568                                                         10987654321098765432109876543210
2569                                                         xxx000010101xxxx1xxxxxxxxx011xxx
2570                                                         bfdot.  */
2571                                                      return 2494;
2572                                                    }
2573                                                  else
2574                                                    {
2575                                                      if (((word >> 12) & 0x1) == 0)
2576                                                        {
2577                                                          /* 33222222222211111111110000000000
2578                                                             10987654321098765432109876543210
2579                                                             xxx000010101xxxx1xx0xxxxxx111xxx
2580                                                             suvdot.  */
2581                                                          return 2844;
2582                                                        }
2583                                                      else
2584                                                        {
2585                                                          /* 33222222222211111111110000000000
2586                                                             10987654321098765432109876543210
2587                                                             xxx000010101xxxx1xx1xxxxxx111xxx
2588                                                             sudot.  */
2589                                                          return 2834;
2590                                                        }
2591                                                    }
2592                                                }
2593                                            }
2594                                        }
2595                                    }
2596                                }
2597                              else
2598                                {
2599                                  if (((word >> 4) & 0x1) == 0)
2600                                    {
2601                                      if (((word >> 29) & 0x1) == 0)
2602                                        {
2603                                          if (((word >> 3) & 0x1) == 0)
2604                                            {
2605                                              if (((word >> 12) & 0x1) == 0)
2606                                                {
2607                                                  if (((word >> 15) & 0x1) == 0)
2608                                                    {
2609                                                      /* 33222222222211111111110000000000
2610                                                         10987654321098765432109876543210
2611                                                         xx000001110xxxxx0xx0xxxxxxx00xxx
2612                                                         fmla.  */
2613                                                      return 2969;
2614                                                    }
2615                                                  else
2616                                                    {
2617                                                      /* 33222222222211111111110000000000
2618                                                         10987654321098765432109876543210
2619                                                         xx000001110xxxxx1xx0xxxxxxx00xxx
2620                                                         fmla.  */
2621                                                      return 2970;
2622                                                    }
2623                                                }
2624                                              else
2625                                                {
2626                                                  if (((word >> 20) & 0x1) == 0)
2627                                                    {
2628                                                      /* 33222222222211111111110000000000
2629                                                         10987654321098765432109876543210
2630                                                         xx0000011100xxxxxxx1xxxxxxx00xxx
2631                                                         smlal.  */
2632                                                      return 2708;
2633                                                    }
2634                                                  else
2635                                                    {
2636                                                      if (((word >> 15) & 0x1) == 0)
2637                                                        {
2638                                                          /* 33222222222211111111110000000000
2639                                                             10987654321098765432109876543210
2640                                                             xx0000011101xxxx0xx1xxxxxxx00xxx
2641                                                             smlal.  */
2642                                                          return 2709;
2643                                                        }
2644                                                      else
2645                                                        {
2646                                                          /* 33222222222211111111110000000000
2647                                                             10987654321098765432109876543210
2648                                                             xx0000011101xxxx1xx1xxxxxxx00xxx
2649                                                             smlal.  */
2650                                                          return 2710;
2651                                                        }
2652                                                    }
2653                                                }
2654                                            }
2655                                          else
2656                                            {
2657                                              if (((word >> 12) & 0x1) == 0)
2658                                                {
2659                                                  if (((word >> 11) & 0x1) == 0)
2660                                                    {
2661                                                      if (((word >> 15) & 0x1) == 0)
2662                                                        {
2663                                                          /* 33222222222211111111110000000000
2664                                                             10987654321098765432109876543210
2665                                                             xx000001110xxxxx0xx00xxxxxx01xxx
2666                                                             sdot.  */
2667                                                          return 2951;
2668                                                        }
2669                                                      else
2670                                                        {
2671                                                          /* 33222222222211111111110000000000
2672                                                             10987654321098765432109876543210
2673                                                             xx000001110xxxxx1xx00xxxxxx01xxx
2674                                                             sdot.  */
2675                                                          return 2952;
2676                                                        }
2677                                                    }
2678                                                  else
2679                                                    {
2680                                                      /* 33222222222211111111110000000000
2681                                                         10987654321098765432109876543210
2682                                                         xx000001110xxxxxxxx01xxxxxx01xxx
2683                                                         svdot.  */
2684                                                      return 2959;
2685                                                    }
2686                                                }
2687                                              else
2688                                                {
2689                                                  if (((word >> 20) & 0x1) == 0)
2690                                                    {
2691                                                      /* 33222222222211111111110000000000
2692                                                         10987654321098765432109876543210
2693                                                         xx0000011100xxxxxxx1xxxxxxx01xxx
2694                                                         smlsl.  */
2695                                                      return 2724;
2696                                                    }
2697                                                  else
2698                                                    {
2699                                                      if (((word >> 15) & 0x1) == 0)
2700                                                        {
2701                                                          /* 33222222222211111111110000000000
2702                                                             10987654321098765432109876543210
2703                                                             xx0000011101xxxx0xx1xxxxxxx01xxx
2704                                                             smlsl.  */
2705                                                          return 2725;
2706                                                        }
2707                                                      else
2708                                                        {
2709                                                          /* 33222222222211111111110000000000
2710                                                             10987654321098765432109876543210
2711                                                             xx0000011101xxxx1xx1xxxxxxx01xxx
2712                                                             smlsl.  */
2713                                                          return 2726;
2714                                                        }
2715                                                    }
2716                                                }
2717                                            }
2718                                        }
2719                                      else
2720                                        {
2721                                          if (((word >> 30) & 0x1) == 0)
2722                                            {
2723                                              /* 33222222222211111111110000000000
2724                                                 10987654321098765432109876543210
2725                                                 x0100001110xxxxxxxxxxxxxxxx0xxxx
2726                                                 usmopa.  */
2727                                              return 2422;
2728                                            }
2729                                          else
2730                                            {
2731                                              /* 33222222222211111111110000000000
2732                                                 10987654321098765432109876543210
2733                                                 x1100001110xxxxxxxxxxxxxxxx0xxxx
2734                                                 ld1q.  */
2735                                              return 2434;
2736                                            }
2737                                        }
2738                                    }
2739                                  else
2740                                    {
2741                                      if (((word >> 3) & 0x1) == 0)
2742                                        {
2743                                          if (((word >> 29) & 0x1) == 0)
2744                                            {
2745                                              if (((word >> 12) & 0x1) == 0)
2746                                                {
2747                                                  if (((word >> 15) & 0x1) == 0)
2748                                                    {
2749                                                      /* 33222222222211111111110000000000
2750                                                         10987654321098765432109876543210
2751                                                         xx000001110xxxxx0xx0xxxxxxx10xxx
2752                                                         fmls.  */
2753                                                      return 2971;
2754                                                    }
2755                                                  else
2756                                                    {
2757                                                      /* 33222222222211111111110000000000
2758                                                         10987654321098765432109876543210
2759                                                         xx000001110xxxxx1xx0xxxxxxx10xxx
2760                                                         fmls.  */
2761                                                      return 2972;
2762                                                    }
2763                                                }
2764                                              else
2765                                                {
2766                                                  if (((word >> 20) & 0x1) == 0)
2767                                                    {
2768                                                      /* 33222222222211111111110000000000
2769                                                         10987654321098765432109876543210
2770                                                         xx0000011100xxxxxxx1xxxxxxx10xxx
2771                                                         umlal.  */
2772                                                      return 2871;
2773                                                    }
2774                                                  else
2775                                                    {
2776                                                      if (((word >> 15) & 0x1) == 0)
2777                                                        {
2778                                                          /* 33222222222211111111110000000000
2779                                                             10987654321098765432109876543210
2780                                                             xx0000011101xxxx0xx1xxxxxxx10xxx
2781                                                             umlal.  */
2782                                                          return 2872;
2783                                                        }
2784                                                      else
2785                                                        {
2786                                                          /* 33222222222211111111110000000000
2787                                                             10987654321098765432109876543210
2788                                                             xx0000011101xxxx1xx1xxxxxxx10xxx
2789                                                             umlal.  */
2790                                                          return 2873;
2791                                                        }
2792                                                    }
2793                                                }
2794                                            }
2795                                          else
2796                                            {
2797                                              /* 33222222222211111111110000000000
2798                                                 10987654321098765432109876543210
2799                                                 xx100001110xxxxxxxxxxxxxxxx10xxx
2800                                                 usmops.  */
2801                                              return 2424;
2802                                            }
2803                                        }
2804                                      else
2805                                        {
2806                                          if (((word >> 12) & 0x1) == 0)
2807                                            {
2808                                              if (((word >> 11) & 0x1) == 0)
2809                                                {
2810                                                  if (((word >> 15) & 0x1) == 0)
2811                                                    {
2812                                                      /* 33222222222211111111110000000000
2813                                                         10987654321098765432109876543210
2814                                                         xxx00001110xxxxx0xx00xxxxxx11xxx
2815                                                         udot.  */
2816                                                      return 2960;
2817                                                    }
2818                                                  else
2819                                                    {
2820                                                      /* 33222222222211111111110000000000
2821                                                         10987654321098765432109876543210
2822                                                         xxx00001110xxxxx1xx00xxxxxx11xxx
2823                                                         udot.  */
2824                                                      return 2961;
2825                                                    }
2826                                                }
2827                                              else
2828                                                {
2829                                                  /* 33222222222211111111110000000000
2830                                                     10987654321098765432109876543210
2831                                                     xxx00001110xxxxxxxx01xxxxxx11xxx
2832                                                     uvdot.  */
2833                                                  return 2968;
2834                                                }
2835                                            }
2836                                          else
2837                                            {
2838                                              if (((word >> 20) & 0x1) == 0)
2839                                                {
2840                                                  /* 33222222222211111111110000000000
2841                                                     10987654321098765432109876543210
2842                                                     xxx000011100xxxxxxx1xxxxxxx11xxx
2843                                                     umlsl.  */
2844                                                  return 2887;
2845                                                }
2846                                              else
2847                                                {
2848                                                  if (((word >> 15) & 0x1) == 0)
2849                                                    {
2850                                                      /* 33222222222211111111110000000000
2851                                                         10987654321098765432109876543210
2852                                                         xxx000011101xxxx0xx1xxxxxxx11xxx
2853                                                         umlsl.  */
2854                                                      return 2888;
2855                                                    }
2856                                                  else
2857                                                    {
2858                                                      /* 33222222222211111111110000000000
2859                                                         10987654321098765432109876543210
2860                                                         xxx000011101xxxx1xx1xxxxxxx11xxx
2861                                                         umlsl.  */
2862                                                      return 2889;
2863                                                    }
2864                                                }
2865                                            }
2866                                        }
2867                                    }
2868                                }
2869                            }
2870                        }
2871                      else
2872                        {
2873                          if (((word >> 29) & 0x1) == 0)
2874                            {
2875                              if (((word >> 30) & 0x1) == 0)
2876                                {
2877                                  if (((word >> 4) & 0x1) == 0)
2878                                    {
2879                                      /* 33222222222211111111110000000000
2880                                         10987654321098765432109876543210
2881                                         x0000001xx1xxxxxxxxxxxxxxxx0xxxx
2882                                         fmopa.  */
2883                                      return 2404;
2884                                    }
2885                                  else
2886                                    {
2887                                      /* 33222222222211111111110000000000
2888                                         10987654321098765432109876543210
2889                                         x0000001xx1xxxxxxxxxxxxxxxx1xxxx
2890                                         fmops.  */
2891                                      return 2407;
2892                                    }
2893                                }
2894                              else
2895                                {
2896                                  if (((word >> 15) & 0x1) == 0)
2897                                    {
2898                                      if (((word >> 3) & 0x1) == 0)
2899                                        {
2900                                          if (((word >> 4) & 0x1) == 0)
2901                                            {
2902                                              if (((word >> 10) & 0x1) == 0)
2903                                                {
2904                                                  if (((word >> 11) & 0x1) == 0)
2905                                                    {
2906                                                      if (((word >> 12) & 0x1) == 0)
2907                                                        {
2908                                                          if (((word >> 2) & 0x1) == 0)
2909                                                            {
2910                                                              if (((word >> 23) & 0x1) == 0)
2911                                                                {
2912                                                                  if (((word >> 20) & 0x1) == 0)
2913                                                                    {
2914                                                                      /* 33222222222211111111110000000000
2915                                                                         10987654321098765432109876543210
2916                                                                         x10000010x10xxxx0xx000xxxxx000xx
2917                                                                         smlall.  */
2918                                                                      return 2720;
2919                                                                    }
2920                                                                  else
2921                                                                    {
2922                                                                      /* 33222222222211111111110000000000
2923                                                                         10987654321098765432109876543210
2924                                                                         x10000010x11xxxx0xx000xxxxx000xx
2925                                                                         smlall.  */
2926                                                                      return 2721;
2927                                                                    }
2928                                                                }
2929                                                              else
2930                                                                {
2931                                                                  if (((word >> 16) & 0x1) == 0)
2932                                                                    {
2933                                                                      /* 33222222222211111111110000000000
2934                                                                         10987654321098765432109876543210
2935                                                                         x10000011x1xxxx00xx000xxxxx000xx
2936                                                                         smlall.  */
2937                                                                      return 2722;
2938                                                                    }
2939                                                                  else
2940                                                                    {
2941                                                                      /* 33222222222211111111110000000000
2942                                                                         10987654321098765432109876543210
2943                                                                         x10000011x1xxxx10xx000xxxxx000xx
2944                                                                         smlall.  */
2945                                                                      return 2723;
2946                                                                    }
2947                                                                }
2948                                                            }
2949                                                          else
2950                                                            {
2951                                                              if (((word >> 23) & 0x1) == 0)
2952                                                                {
2953                                                                  if (((word >> 20) & 0x1) == 0)
2954                                                                    {
2955                                                                      /* 33222222222211111111110000000000
2956                                                                         10987654321098765432109876543210
2957                                                                         x10000010x10xxxx0xx000xxxxx001xx
2958                                                                         usmlall.  */
2959                                                                      return 2925;
2960                                                                    }
2961                                                                  else
2962                                                                    {
2963                                                                      /* 33222222222211111111110000000000
2964                                                                         10987654321098765432109876543210
2965                                                                         x10000010x11xxxx0xx000xxxxx001xx
2966                                                                         usmlall.  */
2967                                                                      return 2926;
2968                                                                    }
2969                                                                }
2970                                                              else
2971                                                                {
2972                                                                  if (((word >> 16) & 0x1) == 0)
2973                                                                    {
2974                                                                      /* 33222222222211111111110000000000
2975                                                                         10987654321098765432109876543210
2976                                                                         x10000011x1xxxx00xx000xxxxx001xx
2977                                                                         usmlall.  */
2978                                                                      return 2927;
2979                                                                    }
2980                                                                  else
2981                                                                    {
2982                                                                      /* 33222222222211111111110000000000
2983                                                                         10987654321098765432109876543210
2984                                                                         x10000011x1xxxx10xx000xxxxx001xx
2985                                                                         usmlall.  */
2986                                                                      return 2928;
2987                                                                    }
2988                                                                }
2989                                                            }
2990                                                        }
2991                                                      else
2992                                                        {
2993                                                          if (((word >> 23) & 0x1) == 0)
2994                                                            {
2995                                                              if (((word >> 20) & 0x1) == 0)
2996                                                                {
2997                                                                  /* 33222222222211111111110000000000
2998                                                                     10987654321098765432109876543210
2999                                                                     x10000010x10xxxx0xx100xxxxx00xxx
3000                                                                     fdot.  */
3001                                                                  return 2531;
3002                                                                }
3003                                                              else
3004                                                                {
3005                                                                  /* 33222222222211111111110000000000
3006                                                                     10987654321098765432109876543210
3007                                                                     x10000010x11xxxx0xx100xxxxx00xxx
3008                                                                     fdot.  */
3009                                                                  return 2532;
3010                                                                }
3011                                                            }
3012                                                          else
3013                                                            {
3014                                                              if (((word >> 16) & 0x1) == 0)
3015                                                                {
3016                                                                  /* 33222222222211111111110000000000
3017                                                                     10987654321098765432109876543210
3018                                                                     x10000011x1xxxx00xx100xxxxx00xxx
3019                                                                     fdot.  */
3020                                                                  return 2533;
3021                                                                }
3022                                                              else
3023                                                                {
3024                                                                  /* 33222222222211111111110000000000
3025                                                                     10987654321098765432109876543210
3026                                                                     x10000011x1xxxx10xx100xxxxx00xxx
3027                                                                     fdot.  */
3028                                                                  return 2534;
3029                                                                }
3030                                                            }
3031                                                        }
3032                                                    }
3033                                                  else
3034                                                    {
3035                                                      if (((word >> 12) & 0x1) == 0)
3036                                                        {
3037                                                          if (((word >> 22) & 0x1) == 0)
3038                                                            {
3039                                                              if (((word >> 23) & 0x1) == 0)
3040                                                                {
3041                                                                  if (((word >> 20) & 0x1) == 0)
3042                                                                    {
3043                                                                      /* 33222222222211111111110000000000
3044                                                                         10987654321098765432109876543210
3045                                                                         x10000010010xxxx0xx010xxxxx00xxx
3046                                                                         fmlal.  */
3047                                                                      return 2561;
3048                                                                    }
3049                                                                  else
3050                                                                    {
3051                                                                      /* 33222222222211111111110000000000
3052                                                                         10987654321098765432109876543210
3053                                                                         x10000010011xxxx0xx010xxxxx00xxx
3054                                                                         fmlal.  */
3055                                                                      return 2562;
3056                                                                    }
3057                                                                }
3058                                                              else
3059                                                                {
3060                                                                  if (((word >> 16) & 0x1) == 0)
3061                                                                    {
3062                                                                      /* 33222222222211111111110000000000
3063                                                                         10987654321098765432109876543210
3064                                                                         x1000001101xxxx00xx010xxxxx00xxx
3065                                                                         fmlal.  */
3066                                                                      return 2563;
3067                                                                    }
3068                                                                  else
3069                                                                    {
3070                                                                      /* 33222222222211111111110000000000
3071                                                                         10987654321098765432109876543210
3072                                                                         x1000001101xxxx10xx010xxxxx00xxx
3073                                                                         fmlal.  */
3074                                                                      return 2564;
3075                                                                    }
3076                                                                }
3077                                                            }
3078                                                          else
3079                                                            {
3080                                                              if (((word >> 23) & 0x1) == 0)
3081                                                                {
3082                                                                  if (((word >> 20) & 0x1) == 0)
3083                                                                    {
3084                                                                      /* 33222222222211111111110000000000
3085                                                                         10987654321098765432109876543210
3086                                                                         x10000010110xxxx0xx010xxxxx00xxx
3087                                                                         smlal.  */
3088                                                                      return 2712;
3089                                                                    }
3090                                                                  else
3091                                                                    {
3092                                                                      /* 33222222222211111111110000000000
3093                                                                         10987654321098765432109876543210
3094                                                                         x10000010111xxxx0xx010xxxxx00xxx
3095                                                                         smlal.  */
3096                                                                      return 2713;
3097                                                                    }
3098                                                                }
3099                                                              else
3100                                                                {
3101                                                                  if (((word >> 16) & 0x1) == 0)
3102                                                                    {
3103                                                                      /* 33222222222211111111110000000000
3104                                                                         10987654321098765432109876543210
3105                                                                         x1000001111xxxx00xx010xxxxx00xxx
3106                                                                         smlal.  */
3107                                                                      return 2714;
3108                                                                    }
3109                                                                  else
3110                                                                    {
3111                                                                      /* 33222222222211111111110000000000
3112                                                                         10987654321098765432109876543210
3113                                                                         x1000001111xxxx10xx010xxxxx00xxx
3114                                                                         smlal.  */
3115                                                                      return 2715;
3116                                                                    }
3117                                                                }
3118                                                            }
3119                                                        }
3120                                                      else
3121                                                        {
3122                                                          if (((word >> 23) & 0x1) == 0)
3123                                                            {
3124                                                              if (((word >> 20) & 0x1) == 0)
3125                                                                {
3126                                                                  /* 33222222222211111111110000000000
3127                                                                     10987654321098765432109876543210
3128                                                                     x10000010x10xxxx0xx110xxxxx00xxx
3129                                                                     fmla.  */
3130                                                                  return 2553;
3131                                                                }
3132                                                              else
3133                                                                {
3134                                                                  /* 33222222222211111111110000000000
3135                                                                     10987654321098765432109876543210
3136                                                                     x10000010x11xxxx0xx110xxxxx00xxx
3137                                                                     fmla.  */
3138                                                                  return 2554;
3139                                                                }
3140                                                            }
3141                                                          else
3142                                                            {
3143                                                              if (((word >> 16) & 0x1) == 0)
3144                                                                {
3145                                                                  /* 33222222222211111111110000000000
3146                                                                     10987654321098765432109876543210
3147                                                                     x10000011x1xxxx00xx110xxxxx00xxx
3148                                                                     fmla.  */
3149                                                                  return 2555;
3150                                                                }
3151                                                              else
3152                                                                {
3153                                                                  /* 33222222222211111111110000000000
3154                                                                     10987654321098765432109876543210
3155                                                                     x10000011x1xxxx10xx110xxxxx00xxx
3156                                                                     fmla.  */
3157                                                                  return 2556;
3158                                                                }
3159                                                            }
3160                                                        }
3161                                                    }
3162                                                }
3163                                              else
3164                                                {
3165                                                  if (((word >> 11) & 0x1) == 0)
3166                                                    {
3167                                                      if (((word >> 12) & 0x1) == 0)
3168                                                        {
3169                                                          if (((word >> 2) & 0x1) == 0)
3170                                                            {
3171                                                              /* 33222222222211111111110000000000
3172                                                                 10987654321098765432109876543210
3173                                                                 x1000001xx1xxxxx0xx001xxxxx000xx
3174                                                                 smlall.  */
3175                                                              return 2719;
3176                                                            }
3177                                                          else
3178                                                            {
3179                                                              /* 33222222222211111111110000000000
3180                                                                 10987654321098765432109876543210
3181                                                                 x1000001xx1xxxxx0xx001xxxxx001xx
3182                                                                 usmlall.  */
3183                                                              return 2924;
3184                                                            }
3185                                                        }
3186                                                      else
3187                                                        {
3188                                                          if (((word >> 23) & 0x1) == 0)
3189                                                            {
3190                                                              if (((word >> 20) & 0x1) == 0)
3191                                                                {
3192                                                                  /* 33222222222211111111110000000000
3193                                                                     10987654321098765432109876543210
3194                                                                     x10000010x10xxxx0xx101xxxxx00xxx
3195                                                                     sdot.  */
3196                                                                  return 2694;
3197                                                                }
3198                                                              else
3199                                                                {
3200                                                                  /* 33222222222211111111110000000000
3201                                                                     10987654321098765432109876543210
3202                                                                     x10000010x11xxxx0xx101xxxxx00xxx
3203                                                                     sdot.  */
3204                                                                  return 2695;
3205                                                                }
3206                                                            }
3207                                                          else
3208                                                            {
3209                                                              if (((word >> 16) & 0x1) == 0)
3210                                                                {
3211                                                                  /* 33222222222211111111110000000000
3212                                                                     10987654321098765432109876543210
3213                                                                     x10000011x1xxxx00xx101xxxxx00xxx
3214                                                                     sdot.  */
3215                                                                  return 2696;
3216                                                                }
3217                                                              else
3218                                                                {
3219                                                                  /* 33222222222211111111110000000000
3220                                                                     10987654321098765432109876543210
3221                                                                     x10000011x1xxxx10xx101xxxxx00xxx
3222                                                                     sdot.  */
3223                                                                  return 2697;
3224                                                                }
3225                                                            }
3226                                                        }
3227                                                    }
3228                                                  else
3229                                                    {
3230                                                      if (((word >> 12) & 0x1) == 0)
3231                                                        {
3232                                                          if (((word >> 22) & 0x1) == 0)
3233                                                            {
3234                                                              /* 33222222222211111111110000000000
3235                                                                 10987654321098765432109876543210
3236                                                                 x1000001x01xxxxx0xx011xxxxx00xxx
3237                                                                 fmlal.  */
3238                                                              return 2560;
3239                                                            }
3240                                                          else
3241                                                            {
3242                                                              /* 33222222222211111111110000000000
3243                                                                 10987654321098765432109876543210
3244                                                                 x1000001x11xxxxx0xx011xxxxx00xxx
3245                                                                 smlal.  */
3246                                                              return 2711;
3247                                                            }
3248                                                        }
3249                                                      else
3250                                                        {
3251                                                          if (((word >> 16) & 0x1) == 0)
3252                                                            {
3253                                                              /* 33222222222211111111110000000000
3254                                                                 10987654321098765432109876543210
3255                                                                 x1000001xx1xxxx00xx111xxxxx00xxx
3256                                                                 fadd.  */
3257                                                              return 2519;
3258                                                            }
3259                                                          else
3260                                                            {
3261                                                              /* 33222222222211111111110000000000
3262                                                                 10987654321098765432109876543210
3263                                                                 x1000001xx1xxxx10xx111xxxxx00xxx
3264                                                                 fadd.  */
3265                                                              return 2520;
3266                                                            }
3267                                                        }
3268                                                    }
3269                                                }
3270                                            }
3271                                          else
3272                                            {
3273                                              if (((word >> 10) & 0x1) == 0)
3274                                                {
3275                                                  if (((word >> 11) & 0x1) == 0)
3276                                                    {
3277                                                      if (((word >> 12) & 0x1) == 0)
3278                                                        {
3279                                                          if (((word >> 2) & 0x1) == 0)
3280                                                            {
3281                                                              if (((word >> 23) & 0x1) == 0)
3282                                                                {
3283                                                                  if (((word >> 20) & 0x1) == 0)
3284                                                                    {
3285                                                                      /* 33222222222211111111110000000000
3286                                                                         10987654321098765432109876543210
3287                                                                         x10000010x10xxxx0xx000xxxxx100xx
3288                                                                         umlall.  */
3289                                                                      return 2883;
3290                                                                    }
3291                                                                  else
3292                                                                    {
3293                                                                      /* 33222222222211111111110000000000
3294                                                                         10987654321098765432109876543210
3295                                                                         x10000010x11xxxx0xx000xxxxx100xx
3296                                                                         umlall.  */
3297                                                                      return 2884;
3298                                                                    }
3299                                                                }
3300                                                              else
3301                                                                {
3302                                                                  if (((word >> 16) & 0x1) == 0)
3303                                                                    {
3304                                                                      /* 33222222222211111111110000000000
3305                                                                         10987654321098765432109876543210
3306                                                                         x10000011x1xxxx00xx000xxxxx100xx
3307                                                                         umlall.  */
3308                                                                      return 2885;
3309                                                                    }
3310                                                                  else
3311                                                                    {
3312                                                                      /* 33222222222211111111110000000000
3313                                                                         10987654321098765432109876543210
3314                                                                         x10000011x1xxxx10xx000xxxxx100xx
3315                                                                         umlall.  */
3316                                                                      return 2886;
3317                                                                    }
3318                                                                }
3319                                                            }
3320                                                          else
3321                                                            {
3322                                                              if (((word >> 20) & 0x1) == 0)
3323                                                                {
3324                                                                  /* 33222222222211111111110000000000
3325                                                                     10987654321098765432109876543210
3326                                                                     x1000001xx10xxxx0xx000xxxxx101xx
3327                                                                     sumlall.  */
3328                                                                  return 2840;
3329                                                                }
3330                                                              else
3331                                                                {
3332                                                                  /* 33222222222211111111110000000000
3333                                                                     10987654321098765432109876543210
3334                                                                     x1000001xx11xxxx0xx000xxxxx101xx
3335                                                                     sumlall.  */
3336                                                                  return 2841;
3337                                                                }
3338                                                            }
3339                                                        }
3340                                                      else
3341                                                        {
3342                                                          if (((word >> 23) & 0x1) == 0)
3343                                                            {
3344                                                              if (((word >> 20) & 0x1) == 0)
3345                                                                {
3346                                                                  /* 33222222222211111111110000000000
3347                                                                     10987654321098765432109876543210
3348                                                                     x10000010x10xxxx0xx100xxxxx10xxx
3349                                                                     bfdot.  */
3350                                                                  return 2495;
3351                                                                }
3352                                                              else
3353                                                                {
3354                                                                  /* 33222222222211111111110000000000
3355                                                                     10987654321098765432109876543210
3356                                                                     x10000010x11xxxx0xx100xxxxx10xxx
3357                                                                     bfdot.  */
3358                                                                  return 2496;
3359                                                                }
3360                                                            }
3361                                                          else
3362                                                            {
3363                                                              if (((word >> 16) & 0x1) == 0)
3364                                                                {
3365                                                                  /* 33222222222211111111110000000000
3366                                                                     10987654321098765432109876543210
3367                                                                     x10000011x1xxxx00xx100xxxxx10xxx
3368                                                                     bfdot.  */
3369                                                                  return 2497;
3370                                                                }
3371                                                              else
3372                                                                {
3373                                                                  /* 33222222222211111111110000000000
3374                                                                     10987654321098765432109876543210
3375                                                                     x10000011x1xxxx10xx100xxxxx10xxx
3376                                                                     bfdot.  */
3377                                                                  return 2498;
3378                                                                }
3379                                                            }
3380                                                        }
3381                                                    }
3382                                                  else
3383                                                    {
3384                                                      if (((word >> 12) & 0x1) == 0)
3385                                                        {
3386                                                          if (((word >> 22) & 0x1) == 0)
3387                                                            {
3388                                                              if (((word >> 23) & 0x1) == 0)
3389                                                                {
3390                                                                  if (((word >> 20) & 0x1) == 0)
3391                                                                    {
3392                                                                      /* 33222222222211111111110000000000
3393                                                                         10987654321098765432109876543210
3394                                                                         x10000010010xxxx0xx010xxxxx10xxx
3395                                                                         bfmlal.  */
3396                                                                      return 2503;
3397                                                                    }
3398                                                                  else
3399                                                                    {
3400                                                                      /* 33222222222211111111110000000000
3401                                                                         10987654321098765432109876543210
3402                                                                         x10000010011xxxx0xx010xxxxx10xxx
3403                                                                         bfmlal.  */
3404                                                                      return 2504;
3405                                                                    }
3406                                                                }
3407                                                              else
3408                                                                {
3409                                                                  if (((word >> 16) & 0x1) == 0)
3410                                                                    {
3411                                                                      /* 33222222222211111111110000000000
3412                                                                         10987654321098765432109876543210
3413                                                                         x1000001101xxxx00xx010xxxxx10xxx
3414                                                                         bfmlal.  */
3415                                                                      return 2505;
3416                                                                    }
3417                                                                  else
3418                                                                    {
3419                                                                      /* 33222222222211111111110000000000
3420                                                                         10987654321098765432109876543210
3421                                                                         x1000001101xxxx10xx010xxxxx10xxx
3422                                                                         bfmlal.  */
3423                                                                      return 2506;
3424                                                                    }
3425                                                                }
3426                                                            }
3427                                                          else
3428                                                            {
3429                                                              if (((word >> 23) & 0x1) == 0)
3430                                                                {
3431                                                                  if (((word >> 20) & 0x1) == 0)
3432                                                                    {
3433                                                                      /* 33222222222211111111110000000000
3434                                                                         10987654321098765432109876543210
3435                                                                         x10000010110xxxx0xx010xxxxx10xxx
3436                                                                         umlal.  */
3437                                                                      return 2875;
3438                                                                    }
3439                                                                  else
3440                                                                    {
3441                                                                      /* 33222222222211111111110000000000
3442                                                                         10987654321098765432109876543210
3443                                                                         x10000010111xxxx0xx010xxxxx10xxx
3444                                                                         umlal.  */
3445                                                                      return 2876;
3446                                                                    }
3447                                                                }
3448                                                              else
3449                                                                {
3450                                                                  if (((word >> 16) & 0x1) == 0)
3451                                                                    {
3452                                                                      /* 33222222222211111111110000000000
3453                                                                         10987654321098765432109876543210
3454                                                                         x1000001111xxxx00xx010xxxxx10xxx
3455                                                                         umlal.  */
3456                                                                      return 2877;
3457                                                                    }
3458                                                                  else
3459                                                                    {
3460                                                                      /* 33222222222211111111110000000000
3461                                                                         10987654321098765432109876543210
3462                                                                         x1000001111xxxx10xx010xxxxx10xxx
3463                                                                         umlal.  */
3464                                                                      return 2878;
3465                                                                    }
3466                                                                }
3467                                                            }
3468                                                        }
3469                                                      else
3470                                                        {
3471                                                          if (((word >> 23) & 0x1) == 0)
3472                                                            {
3473                                                              if (((word >> 20) & 0x1) == 0)
3474                                                                {
3475                                                                  /* 33222222222211111111110000000000
3476                                                                     10987654321098765432109876543210
3477                                                                     x10000010x10xxxx0xx110xxxxx10xxx
3478                                                                     add.  */
3479                                                                  return 2485;
3480                                                                }
3481                                                              else
3482                                                                {
3483                                                                  /* 33222222222211111111110000000000
3484                                                                     10987654321098765432109876543210
3485                                                                     x10000010x11xxxx0xx110xxxxx10xxx
3486                                                                     add.  */
3487                                                                  return 2486;
3488                                                                }
3489                                                            }
3490                                                          else
3491                                                            {
3492                                                              if (((word >> 16) & 0x1) == 0)
3493                                                                {
3494                                                                  /* 33222222222211111111110000000000
3495                                                                     10987654321098765432109876543210
3496                                                                     x10000011x1xxxx00xx110xxxxx10xxx
3497                                                                     add.  */
3498                                                                  return 2487;
3499                                                                }
3500                                                              else
3501                                                                {
3502                                                                  /* 33222222222211111111110000000000
3503                                                                     10987654321098765432109876543210
3504                                                                     x10000011x1xxxx10xx110xxxxx10xxx
3505                                                                     add.  */
3506                                                                  return 2488;
3507                                                                }
3508                                                            }
3509                                                        }
3510                                                    }
3511                                                }
3512                                              else
3513                                                {
3514                                                  if (((word >> 11) & 0x1) == 0)
3515                                                    {
3516                                                      if (((word >> 12) & 0x1) == 0)
3517                                                        {
3518                                                          /* 33222222222211111111110000000000
3519                                                             10987654321098765432109876543210
3520                                                             x1000001xx1xxxxx0xx001xxxxx10xxx
3521                                                             umlall.  */
3522                                                          return 2882;
3523                                                        }
3524                                                      else
3525                                                        {
3526                                                          if (((word >> 23) & 0x1) == 0)
3527                                                            {
3528                                                              if (((word >> 20) & 0x1) == 0)
3529                                                                {
3530                                                                  /* 33222222222211111111110000000000
3531                                                                     10987654321098765432109876543210
3532                                                                     x10000010x10xxxx0xx101xxxxx10xxx
3533                                                                     udot.  */
3534                                                                  return 2859;
3535                                                                }
3536                                                              else
3537                                                                {
3538                                                                  /* 33222222222211111111110000000000
3539                                                                     10987654321098765432109876543210
3540                                                                     x10000010x11xxxx0xx101xxxxx10xxx
3541                                                                     udot.  */
3542                                                                  return 2860;
3543                                                                }
3544                                                            }
3545                                                          else
3546                                                            {
3547                                                              if (((word >> 16) & 0x1) == 0)
3548                                                                {
3549                                                                  /* 33222222222211111111110000000000
3550                                                                     10987654321098765432109876543210
3551                                                                     x10000011x1xxxx00xx101xxxxx10xxx
3552                                                                     udot.  */
3553                                                                  return 2861;
3554                                                                }
3555                                                              else
3556                                                                {
3557                                                                  /* 33222222222211111111110000000000
3558                                                                     10987654321098765432109876543210
3559                                                                     x10000011x1xxxx10xx101xxxxx10xxx
3560                                                                     udot.  */
3561                                                                  return 2862;
3562                                                                }
3563                                                            }
3564                                                        }
3565                                                    }
3566                                                  else
3567                                                    {
3568                                                      if (((word >> 12) & 0x1) == 0)
3569                                                        {
3570                                                          if (((word >> 22) & 0x1) == 0)
3571                                                            {
3572                                                              /* 33222222222211111111110000000000
3573                                                                 10987654321098765432109876543210
3574                                                                 x1000001x01xxxxx0xx011xxxxx10xxx
3575                                                                 bfmlal.  */
3576                                                              return 2502;
3577                                                            }
3578                                                          else
3579                                                            {
3580                                                              /* 33222222222211111111110000000000
3581                                                                 10987654321098765432109876543210
3582                                                                 x1000001x11xxxxx0xx011xxxxx10xxx
3583                                                                 umlal.  */
3584                                                              return 2874;
3585                                                            }
3586                                                        }
3587                                                      else
3588                                                        {
3589                                                          if (((word >> 16) & 0x1) == 0)
3590                                                            {
3591                                                              /* 33222222222211111111110000000000
3592                                                                 10987654321098765432109876543210
3593                                                                 x1000001xx1xxxx00xx111xxxxx10xxx
3594                                                                 add.  */
3595                                                              return 2483;
3596                                                            }
3597                                                          else
3598                                                            {
3599                                                              /* 33222222222211111111110000000000
3600                                                                 10987654321098765432109876543210
3601                                                                 x1000001xx1xxxx10xx111xxxxx10xxx
3602                                                                 add.  */
3603                                                              return 2484;
3604                                                            }
3605                                                        }
3606                                                    }
3607                                                }
3608                                            }
3609                                        }
3610                                      else
3611                                        {
3612                                          if (((word >> 4) & 0x1) == 0)
3613                                            {
3614                                              if (((word >> 10) & 0x1) == 0)
3615                                                {
3616                                                  if (((word >> 11) & 0x1) == 0)
3617                                                    {
3618                                                      if (((word >> 23) & 0x1) == 0)
3619                                                        {
3620                                                          if (((word >> 20) & 0x1) == 0)
3621                                                            {
3622                                                              /* 33222222222211111111110000000000
3623                                                                 10987654321098765432109876543210
3624                                                                 x10000010x10xxxx0xxx00xxxxx01xxx
3625                                                                 smlsll.  */
3626                                                              return 2736;
3627                                                            }
3628                                                          else
3629                                                            {
3630                                                              /* 33222222222211111111110000000000
3631                                                                 10987654321098765432109876543210
3632                                                                 x10000010x11xxxx0xxx00xxxxx01xxx
3633                                                                 smlsll.  */
3634                                                              return 2737;
3635                                                            }
3636                                                        }
3637                                                      else
3638                                                        {
3639                                                          if (((word >> 16) & 0x1) == 0)
3640                                                            {
3641                                                              /* 33222222222211111111110000000000
3642                                                                 10987654321098765432109876543210
3643                                                                 x10000011x1xxxx00xxx00xxxxx01xxx
3644                                                                 smlsll.  */
3645                                                              return 2738;
3646                                                            }
3647                                                          else
3648                                                            {
3649                                                              /* 33222222222211111111110000000000
3650                                                                 10987654321098765432109876543210
3651                                                                 x10000011x1xxxx10xxx00xxxxx01xxx
3652                                                                 smlsll.  */
3653                                                              return 2739;
3654                                                            }
3655                                                        }
3656                                                    }
3657                                                  else
3658                                                    {
3659                                                      if (((word >> 12) & 0x1) == 0)
3660                                                        {
3661                                                          if (((word >> 22) & 0x1) == 0)
3662                                                            {
3663                                                              if (((word >> 23) & 0x1) == 0)
3664                                                                {
3665                                                                  if (((word >> 20) & 0x1) == 0)
3666                                                                    {
3667                                                                      /* 33222222222211111111110000000000
3668                                                                         10987654321098765432109876543210
3669                                                                         x10000010010xxxx0xx010xxxxx01xxx
3670                                                                         fmlsl.  */
3671                                                                      return 2575;
3672                                                                    }
3673                                                                  else
3674                                                                    {
3675                                                                      /* 33222222222211111111110000000000
3676                                                                         10987654321098765432109876543210
3677                                                                         x10000010011xxxx0xx010xxxxx01xxx
3678                                                                         fmlsl.  */
3679                                                                      return 2576;
3680                                                                    }
3681                                                                }
3682                                                              else
3683                                                                {
3684                                                                  if (((word >> 16) & 0x1) == 0)
3685                                                                    {
3686                                                                      /* 33222222222211111111110000000000
3687                                                                         10987654321098765432109876543210
3688                                                                         x1000001101xxxx00xx010xxxxx01xxx
3689                                                                         fmlsl.  */
3690                                                                      return 2577;
3691                                                                    }
3692                                                                  else
3693                                                                    {
3694                                                                      /* 33222222222211111111110000000000
3695                                                                         10987654321098765432109876543210
3696                                                                         x1000001101xxxx10xx010xxxxx01xxx
3697                                                                         fmlsl.  */
3698                                                                      return 2578;
3699                                                                    }
3700                                                                }
3701                                                            }
3702                                                          else
3703                                                            {
3704                                                              if (((word >> 23) & 0x1) == 0)
3705                                                                {
3706                                                                  if (((word >> 20) & 0x1) == 0)
3707                                                                    {
3708                                                                      /* 33222222222211111111110000000000
3709                                                                         10987654321098765432109876543210
3710                                                                         x10000010110xxxx0xx010xxxxx01xxx
3711                                                                         smlsl.  */
3712                                                                      return 2728;
3713                                                                    }
3714                                                                  else
3715                                                                    {
3716                                                                      /* 33222222222211111111110000000000
3717                                                                         10987654321098765432109876543210
3718                                                                         x10000010111xxxx0xx010xxxxx01xxx
3719                                                                         smlsl.  */
3720                                                                      return 2729;
3721                                                                    }
3722                                                                }
3723                                                              else
3724                                                                {
3725                                                                  if (((word >> 16) & 0x1) == 0)
3726                                                                    {
3727                                                                      /* 33222222222211111111110000000000
3728                                                                         10987654321098765432109876543210
3729                                                                         x1000001111xxxx00xx010xxxxx01xxx
3730                                                                         smlsl.  */
3731                                                                      return 2730;
3732                                                                    }
3733                                                                  else
3734                                                                    {
3735                                                                      /* 33222222222211111111110000000000
3736                                                                         10987654321098765432109876543210
3737                                                                         x1000001111xxxx10xx010xxxxx01xxx
3738                                                                         smlsl.  */
3739                                                                      return 2731;
3740                                                                    }
3741                                                                }
3742                                                            }
3743                                                        }
3744                                                      else
3745                                                        {
3746                                                          if (((word >> 23) & 0x1) == 0)
3747                                                            {
3748                                                              if (((word >> 20) & 0x1) == 0)
3749                                                                {
3750                                                                  /* 33222222222211111111110000000000
3751                                                                     10987654321098765432109876543210
3752                                                                     x10000010x10xxxx0xx110xxxxx01xxx
3753                                                                     fmls.  */
3754                                                                  return 2567;
3755                                                                }
3756                                                              else
3757                                                                {
3758                                                                  /* 33222222222211111111110000000000
3759                                                                     10987654321098765432109876543210
3760                                                                     x10000010x11xxxx0xx110xxxxx01xxx
3761                                                                     fmls.  */
3762                                                                  return 2568;
3763                                                                }
3764                                                            }
3765                                                          else
3766                                                            {
3767                                                              if (((word >> 16) & 0x1) == 0)
3768                                                                {
3769                                                                  /* 33222222222211111111110000000000
3770                                                                     10987654321098765432109876543210
3771                                                                     x10000011x1xxxx00xx110xxxxx01xxx
3772                                                                     fmls.  */
3773                                                                  return 2569;
3774                                                                }
3775                                                              else
3776                                                                {
3777                                                                  /* 33222222222211111111110000000000
3778                                                                     10987654321098765432109876543210
3779                                                                     x10000011x1xxxx10xx110xxxxx01xxx
3780                                                                     fmls.  */
3781                                                                  return 2570;
3782                                                                }
3783                                                            }
3784                                                        }
3785                                                    }
3786                                                }
3787                                              else
3788                                                {
3789                                                  if (((word >> 11) & 0x1) == 0)
3790                                                    {
3791                                                      if (((word >> 12) & 0x1) == 0)
3792                                                        {
3793                                                          /* 33222222222211111111110000000000
3794                                                             10987654321098765432109876543210
3795                                                             x1000001xx1xxxxx0xx001xxxxx01xxx
3796                                                             smlsll.  */
3797                                                          return 2735;
3798                                                        }
3799                                                      else
3800                                                        {
3801                                                          if (((word >> 22) & 0x1) == 0)
3802                                                            {
3803                                                              if (((word >> 23) & 0x1) == 0)
3804                                                                {
3805                                                                  if (((word >> 20) & 0x1) == 0)
3806                                                                    {
3807                                                                      /* 33222222222211111111110000000000
3808                                                                         10987654321098765432109876543210
3809                                                                         x10000010010xxxx0xx101xxxxx01xxx
3810                                                                         usdot.  */
3811                                                                      return 2917;
3812                                                                    }
3813                                                                  else
3814                                                                    {
3815                                                                      /* 33222222222211111111110000000000
3816                                                                         10987654321098765432109876543210
3817                                                                         x10000010011xxxx0xx101xxxxx01xxx
3818                                                                         usdot.  */
3819                                                                      return 2918;
3820                                                                    }
3821                                                                }
3822                                                              else
3823                                                                {
3824                                                                  if (((word >> 16) & 0x1) == 0)
3825                                                                    {
3826                                                                      /* 33222222222211111111110000000000
3827                                                                         10987654321098765432109876543210
3828                                                                         x1000001101xxxx00xx101xxxxx01xxx
3829                                                                         usdot.  */
3830                                                                      return 2919;
3831                                                                    }
3832                                                                  else
3833                                                                    {
3834                                                                      /* 33222222222211111111110000000000
3835                                                                         10987654321098765432109876543210
3836                                                                         x1000001101xxxx10xx101xxxxx01xxx
3837                                                                         usdot.  */
3838                                                                      return 2920;
3839                                                                    }
3840                                                                }
3841                                                            }
3842                                                          else
3843                                                            {
3844                                                              if (((word >> 23) & 0x1) == 0)
3845                                                                {
3846                                                                  if (((word >> 20) & 0x1) == 0)
3847                                                                    {
3848                                                                      /* 33222222222211111111110000000000
3849                                                                         10987654321098765432109876543210
3850                                                                         x10000010110xxxx0xx101xxxxx01xxx
3851                                                                         sdot.  */
3852                                                                      return 2688;
3853                                                                    }
3854                                                                  else
3855                                                                    {
3856                                                                      /* 33222222222211111111110000000000
3857                                                                         10987654321098765432109876543210
3858                                                                         x10000010111xxxx0xx101xxxxx01xxx
3859                                                                         sdot.  */
3860                                                                      return 2689;
3861                                                                    }
3862                                                                }
3863                                                              else
3864                                                                {
3865                                                                  if (((word >> 16) & 0x1) == 0)
3866                                                                    {
3867                                                                      /* 33222222222211111111110000000000
3868                                                                         10987654321098765432109876543210
3869                                                                         x1000001111xxxx00xx101xxxxx01xxx
3870                                                                         sdot.  */
3871                                                                      return 2690;
3872                                                                    }
3873                                                                  else
3874                                                                    {
3875                                                                      /* 33222222222211111111110000000000
3876                                                                         10987654321098765432109876543210
3877                                                                         x1000001111xxxx10xx101xxxxx01xxx
3878                                                                         sdot.  */
3879                                                                      return 2691;
3880                                                                    }
3881                                                                }
3882                                                            }
3883                                                        }
3884                                                    }
3885                                                  else
3886                                                    {
3887                                                      if (((word >> 12) & 0x1) == 0)
3888                                                        {
3889                                                          if (((word >> 22) & 0x1) == 0)
3890                                                            {
3891                                                              /* 33222222222211111111110000000000
3892                                                                 10987654321098765432109876543210
3893                                                                 x1000001x01xxxxx0xx011xxxxx01xxx
3894                                                                 fmlsl.  */
3895                                                              return 2574;
3896                                                            }
3897                                                          else
3898                                                            {
3899                                                              /* 33222222222211111111110000000000
3900                                                                 10987654321098765432109876543210
3901                                                                 x1000001x11xxxxx0xx011xxxxx01xxx
3902                                                                 smlsl.  */
3903                                                              return 2727;
3904                                                            }
3905                                                        }
3906                                                      else
3907                                                        {
3908                                                          if (((word >> 16) & 0x1) == 0)
3909                                                            {
3910                                                              /* 33222222222211111111110000000000
3911                                                                 10987654321098765432109876543210
3912                                                                 x1000001xx1xxxx00xx111xxxxx01xxx
3913                                                                 fsub.  */
3914                                                              return 2587;
3915                                                            }
3916                                                          else
3917                                                            {
3918                                                              /* 33222222222211111111110000000000
3919                                                                 10987654321098765432109876543210
3920                                                                 x1000001xx1xxxx10xx111xxxxx01xxx
3921                                                                 fsub.  */
3922                                                              return 2588;
3923                                                            }
3924                                                        }
3925                                                    }
3926                                                }
3927                                            }
3928                                          else
3929                                            {
3930                                              if (((word >> 10) & 0x1) == 0)
3931                                                {
3932                                                  if (((word >> 11) & 0x1) == 0)
3933                                                    {
3934                                                      if (((word >> 23) & 0x1) == 0)
3935                                                        {
3936                                                          if (((word >> 20) & 0x1) == 0)
3937                                                            {
3938                                                              /* 33222222222211111111110000000000
3939                                                                 10987654321098765432109876543210
3940                                                                 x10000010x10xxxx0xxx00xxxxx11xxx
3941                                                                 umlsll.  */
3942                                                              return 2899;
3943                                                            }
3944                                                          else
3945                                                            {
3946                                                              /* 33222222222211111111110000000000
3947                                                                 10987654321098765432109876543210
3948                                                                 x10000010x11xxxx0xxx00xxxxx11xxx
3949                                                                 umlsll.  */
3950                                                              return 2900;
3951                                                            }
3952                                                        }
3953                                                      else
3954                                                        {
3955                                                          if (((word >> 16) & 0x1) == 0)
3956                                                            {
3957                                                              /* 33222222222211111111110000000000
3958                                                                 10987654321098765432109876543210
3959                                                                 x10000011x1xxxx00xxx00xxxxx11xxx
3960                                                                 umlsll.  */
3961                                                              return 2901;
3962                                                            }
3963                                                          else
3964                                                            {
3965                                                              /* 33222222222211111111110000000000
3966                                                                 10987654321098765432109876543210
3967                                                                 x10000011x1xxxx10xxx00xxxxx11xxx
3968                                                                 umlsll.  */
3969                                                              return 2902;
3970                                                            }
3971                                                        }
3972                                                    }
3973                                                  else
3974                                                    {
3975                                                      if (((word >> 12) & 0x1) == 0)
3976                                                        {
3977                                                          if (((word >> 22) & 0x1) == 0)
3978                                                            {
3979                                                              if (((word >> 23) & 0x1) == 0)
3980                                                                {
3981                                                                  if (((word >> 20) & 0x1) == 0)
3982                                                                    {
3983                                                                      /* 33222222222211111111110000000000
3984                                                                         10987654321098765432109876543210
3985                                                                         x10000010010xxxx0xx010xxxxx11xxx
3986                                                                         bfmlsl.  */
3987                                                                      return 2511;
3988                                                                    }
3989                                                                  else
3990                                                                    {
3991                                                                      /* 33222222222211111111110000000000
3992                                                                         10987654321098765432109876543210
3993                                                                         x10000010011xxxx0xx010xxxxx11xxx
3994                                                                         bfmlsl.  */
3995                                                                      return 2512;
3996                                                                    }
3997                                                                }
3998                                                              else
3999                                                                {
4000                                                                  if (((word >> 16) & 0x1) == 0)
4001                                                                    {
4002                                                                      /* 33222222222211111111110000000000
4003                                                                         10987654321098765432109876543210
4004                                                                         x1000001101xxxx00xx010xxxxx11xxx
4005                                                                         bfmlsl.  */
4006                                                                      return 2513;
4007                                                                    }
4008                                                                  else
4009                                                                    {
4010                                                                      /* 33222222222211111111110000000000
4011                                                                         10987654321098765432109876543210
4012                                                                         x1000001101xxxx10xx010xxxxx11xxx
4013                                                                         bfmlsl.  */
4014                                                                      return 2514;
4015                                                                    }
4016                                                                }
4017                                                            }
4018                                                          else
4019                                                            {
4020                                                              if (((word >> 23) & 0x1) == 0)
4021                                                                {
4022                                                                  if (((word >> 20) & 0x1) == 0)
4023                                                                    {
4024                                                                      /* 33222222222211111111110000000000
4025                                                                         10987654321098765432109876543210
4026                                                                         x10000010110xxxx0xx010xxxxx11xxx
4027                                                                         umlsl.  */
4028                                                                      return 2891;
4029                                                                    }
4030                                                                  else
4031                                                                    {
4032                                                                      /* 33222222222211111111110000000000
4033                                                                         10987654321098765432109876543210
4034                                                                         x10000010111xxxx0xx010xxxxx11xxx
4035                                                                         umlsl.  */
4036                                                                      return 2892;
4037                                                                    }
4038                                                                }
4039                                                              else
4040                                                                {
4041                                                                  if (((word >> 16) & 0x1) == 0)
4042                                                                    {
4043                                                                      /* 33222222222211111111110000000000
4044                                                                         10987654321098765432109876543210
4045                                                                         x1000001111xxxx00xx010xxxxx11xxx
4046                                                                         umlsl.  */
4047                                                                      return 2893;
4048                                                                    }
4049                                                                  else
4050                                                                    {
4051                                                                      /* 33222222222211111111110000000000
4052                                                                         10987654321098765432109876543210
4053                                                                         x1000001111xxxx10xx010xxxxx11xxx
4054                                                                         umlsl.  */
4055                                                                      return 2894;
4056                                                                    }
4057                                                                }
4058                                                            }
4059                                                        }
4060                                                      else
4061                                                        {
4062                                                          if (((word >> 23) & 0x1) == 0)
4063                                                            {
4064                                                              if (((word >> 20) & 0x1) == 0)
4065                                                                {
4066                                                                  /* 33222222222211111111110000000000
4067                                                                     10987654321098765432109876543210
4068                                                                     x10000010x10xxxx0xx110xxxxx11xxx
4069                                                                     sub.  */
4070                                                                  return 2829;
4071                                                                }
4072                                                              else
4073                                                                {
4074                                                                  /* 33222222222211111111110000000000
4075                                                                     10987654321098765432109876543210
4076                                                                     x10000010x11xxxx0xx110xxxxx11xxx
4077                                                                     sub.  */
4078                                                                  return 2830;
4079                                                                }
4080                                                            }
4081                                                          else
4082                                                            {
4083                                                              if (((word >> 16) & 0x1) == 0)
4084                                                                {
4085                                                                  /* 33222222222211111111110000000000
4086                                                                     10987654321098765432109876543210
4087                                                                     x10000011x1xxxx00xx110xxxxx11xxx
4088                                                                     sub.  */
4089                                                                  return 2831;
4090                                                                }
4091                                                              else
4092                                                                {
4093                                                                  /* 33222222222211111111110000000000
4094                                                                     10987654321098765432109876543210
4095                                                                     x10000011x1xxxx10xx110xxxxx11xxx
4096                                                                     sub.  */
4097                                                                  return 2832;
4098                                                                }
4099                                                            }
4100                                                        }
4101                                                    }
4102                                                }
4103                                              else
4104                                                {
4105                                                  if (((word >> 11) & 0x1) == 0)
4106                                                    {
4107                                                      if (((word >> 12) & 0x1) == 0)
4108                                                        {
4109                                                          /* 33222222222211111111110000000000
4110                                                             10987654321098765432109876543210
4111                                                             x1000001xx1xxxxx0xx001xxxxx11xxx
4112                                                             umlsll.  */
4113                                                          return 2898;
4114                                                        }
4115                                                      else
4116                                                        {
4117                                                          if (((word >> 22) & 0x1) == 0)
4118                                                            {
4119                                                              if (((word >> 20) & 0x1) == 0)
4120                                                                {
4121                                                                  /* 33222222222211111111110000000000
4122                                                                     10987654321098765432109876543210
4123                                                                     x1000001x010xxxx0xx101xxxxx11xxx
4124                                                                     sudot.  */
4125                                                                  return 2835;
4126                                                                }
4127                                                              else
4128                                                                {
4129                                                                  /* 33222222222211111111110000000000
4130                                                                     10987654321098765432109876543210
4131                                                                     x1000001x011xxxx0xx101xxxxx11xxx
4132                                                                     sudot.  */
4133                                                                  return 2836;
4134                                                                }
4135                                                            }
4136                                                          else
4137                                                            {
4138                                                              if (((word >> 23) & 0x1) == 0)
4139                                                                {
4140                                                                  if (((word >> 20) & 0x1) == 0)
4141                                                                    {
4142                                                                      /* 33222222222211111111110000000000
4143                                                                         10987654321098765432109876543210
4144                                                                         x10000010110xxxx0xx101xxxxx11xxx
4145                                                                         udot.  */
4146                                                                      return 2853;
4147                                                                    }
4148                                                                  else
4149                                                                    {
4150                                                                      /* 33222222222211111111110000000000
4151                                                                         10987654321098765432109876543210
4152                                                                         x10000010111xxxx0xx101xxxxx11xxx
4153                                                                         udot.  */
4154                                                                      return 2854;
4155                                                                    }
4156                                                                }
4157                                                              else
4158                                                                {
4159                                                                  if (((word >> 16) & 0x1) == 0)
4160                                                                    {
4161                                                                      /* 33222222222211111111110000000000
4162                                                                         10987654321098765432109876543210
4163                                                                         x1000001111xxxx00xx101xxxxx11xxx
4164                                                                         udot.  */
4165                                                                      return 2855;
4166                                                                    }
4167                                                                  else
4168                                                                    {
4169                                                                      /* 33222222222211111111110000000000
4170                                                                         10987654321098765432109876543210
4171                                                                         x1000001111xxxx10xx101xxxxx11xxx
4172                                                                         udot.  */
4173                                                                      return 2856;
4174                                                                    }
4175                                                                }
4176                                                            }
4177                                                        }
4178                                                    }
4179                                                  else
4180                                                    {
4181                                                      if (((word >> 12) & 0x1) == 0)
4182                                                        {
4183                                                          if (((word >> 22) & 0x1) == 0)
4184                                                            {
4185                                                              /* 33222222222211111111110000000000
4186                                                                 10987654321098765432109876543210
4187                                                                 x1000001x01xxxxx0xx011xxxxx11xxx
4188                                                                 bfmlsl.  */
4189                                                              return 2510;
4190                                                            }
4191                                                          else
4192                                                            {
4193                                                              /* 33222222222211111111110000000000
4194                                                                 10987654321098765432109876543210
4195                                                                 x1000001x11xxxxx0xx011xxxxx11xxx
4196                                                                 umlsl.  */
4197                                                              return 2890;
4198                                                            }
4199                                                        }
4200                                                      else
4201                                                        {
4202                                                          if (((word >> 16) & 0x1) == 0)
4203                                                            {
4204                                                              /* 33222222222211111111110000000000
4205                                                                 10987654321098765432109876543210
4206                                                                 x1000001xx1xxxx00xx111xxxxx11xxx
4207                                                                 sub.  */
4208                                                              return 2827;
4209                                                            }
4210                                                          else
4211                                                            {
4212                                                              /* 33222222222211111111110000000000
4213                                                                 10987654321098765432109876543210
4214                                                                 x1000001xx1xxxx10xx111xxxxx11xxx
4215                                                                 sub.  */
4216                                                              return 2828;
4217                                                            }
4218                                                        }
4219                                                    }
4220                                                }
4221                                            }
4222                                        }
4223                                    }
4224                                  else
4225                                    {
4226                                      if (((word >> 13) & 0x1) == 0)
4227                                        {
4228                                          if (((word >> 14) & 0x1) == 0)
4229                                            {
4230                                              if (((word >> 16) & 0x1) == 0)
4231                                                {
4232                                                  /* 33222222222211111111110000000000
4233                                                     10987654321098765432109876543210
4234                                                     x1000001xx1xxxx0100xxxxxxxxxxxxx
4235                                                     sel.  */
4236                                                  return 2698;
4237                                                }
4238                                              else
4239                                                {
4240                                                  /* 33222222222211111111110000000000
4241                                                     10987654321098765432109876543210
4242                                                     x1000001xx1xxxx1100xxxxxxxxxxxxx
4243                                                     sel.  */
4244                                                  return 2699;
4245                                                }
4246                                            }
4247                                          else
4248                                            {
4249                                              if (((word >> 10) & 0x1) == 0)
4250                                                {
4251                                                  if (((word >> 11) & 0x1) == 0)
4252                                                    {
4253                                                      if (((word >> 0) & 0x1) == 0)
4254                                                        {
4255                                                          if (((word >> 12) & 0x1) == 0)
4256                                                            {
4257                                                              /* 33222222222211111111110000000000
4258                                                                 10987654321098765432109876543210
4259                                                                 x1000001xx1xxxxx110000xxxxxxxxx0
4260                                                                 fclamp.  */
4261                                                              return 2521;
4262                                                            }
4263                                                          else
4264                                                            {
4265                                                              /* 33222222222211111111110000000000
4266                                                                 10987654321098765432109876543210
4267                                                                 x1000001xx1xxxxx110100xxxxxxxxx0
4268                                                                 zip.  */
4269                                                              return 2947;
4270                                                            }
4271                                                        }
4272                                                      else
4273                                                        {
4274                                                          /* 33222222222211111111110000000000
4275                                                             10987654321098765432109876543210
4276                                                             x1000001xx1xxxxx110x00xxxxxxxxx1
4277                                                             uzp.  */
4278                                                          return 2934;
4279                                                        }
4280                                                    }
4281                                                  else
4282                                                    {
4283                                                      if (((word >> 12) & 0x1) == 0)
4284                                                        {
4285                                                          /* 33222222222211111111110000000000
4286                                                             10987654321098765432109876543210
4287                                                             x1000001xx1xxxxx110010xxxxxxxxxx
4288                                                             fclamp.  */
4289                                                          return 2522;
4290                                                        }
4291                                                      else
4292                                                        {
4293                                                          if (((word >> 5) & 0x1) == 0)
4294                                                            {
4295                                                              if (((word >> 6) & 0x1) == 0)
4296                                                                {
4297                                                                  /* 33222222222211111111110000000000
4298                                                                     10987654321098765432109876543210
4299                                                                     x1000001xx1xxxxx110110xxx00xxxxx
4300                                                                     sqrshr.  */
4301                                                                  return 2753;
4302                                                                }
4303                                                              else
4304                                                                {
4305                                                                  /* 33222222222211111111110000000000
4306                                                                     10987654321098765432109876543210
4307                                                                     x1000001xx1xxxxx110110xxx10xxxxx
4308                                                                     sqrshru.  */
4309                                                                  return 2756;
4310                                                                }
4311                                                            }
4312                                                          else
4313                                                            {
4314                                                              /* 33222222222211111111110000000000
4315                                                                 10987654321098765432109876543210
4316                                                                 x1000001xx1xxxxx110110xxxx1xxxxx
4317                                                                 uqrshr.  */
4318                                                              return 2909;
4319                                                            }
4320                                                        }
4321                                                    }
4322                                                }
4323                                              else
4324                                                {
4325                                                  if (((word >> 11) & 0x1) == 0)
4326                                                    {
4327                                                      if (((word >> 12) & 0x1) == 0)
4328                                                        {
4329                                                          if (((word >> 0) & 0x1) == 0)
4330                                                            {
4331                                                              /* 33222222222211111111110000000000
4332                                                                 10987654321098765432109876543210
4333                                                                 x1000001xx1xxxxx110001xxxxxxxxx0
4334                                                                 sclamp.  */
4335                                                              return 2682;
4336                                                            }
4337                                                          else
4338                                                            {
4339                                                              /* 33222222222211111111110000000000
4340                                                                 10987654321098765432109876543210
4341                                                                 x1000001xx1xxxxx110001xxxxxxxxx1
4342                                                                 uclamp.  */
4343                                                              return 2847;
4344                                                            }
4345                                                        }
4346                                                      else
4347                                                        {
4348                                                          if (((word >> 22) & 0x1) == 0)
4349                                                            {
4350                                                              if (((word >> 0) & 0x1) == 0)
4351                                                                {
4352                                                                  /* 33222222222211111111110000000000
4353                                                                     10987654321098765432109876543210
4354                                                                     x1000001x01xxxxx110101xxxxxxxxx0
4355                                                                     zip.  */
4356                                                                  return 2948;
4357                                                                }
4358                                                              else
4359                                                                {
4360                                                                  /* 33222222222211111111110000000000
4361                                                                     10987654321098765432109876543210
4362                                                                     x1000001x01xxxxx110101xxxxxxxxx1
4363                                                                     uzp.  */
4364                                                                  return 2935;
4365                                                                }
4366                                                            }
4367                                                          else
4368                                                            {
4369                                                              if (((word >> 5) & 0x1) == 0)
4370                                                                {
4371                                                                  if (((word >> 20) & 0x1) == 0)
4372                                                                    {
4373                                                                      /* 33222222222211111111110000000000
4374                                                                         10987654321098765432109876543210
4375                                                                         x1000001x110xxxx110101xxxx0xxxxx
4376                                                                         sqrshr.  */
4377                                                                      return 2752;
4378                                                                    }
4379                                                                  else
4380                                                                    {
4381                                                                      /* 33222222222211111111110000000000
4382                                                                         10987654321098765432109876543210
4383                                                                         x1000001x111xxxx110101xxxx0xxxxx
4384                                                                         sqrshru.  */
4385                                                                      return 2755;
4386                                                                    }
4387                                                                }
4388                                                              else
4389                                                                {
4390                                                                  /* 33222222222211111111110000000000
4391                                                                     10987654321098765432109876543210
4392                                                                     x1000001x11xxxxx110101xxxx1xxxxx
4393                                                                     uqrshr.  */
4394                                                                  return 2908;
4395                                                                }
4396                                                            }
4397                                                        }
4398                                                    }
4399                                                  else
4400                                                    {
4401                                                      if (((word >> 12) & 0x1) == 0)
4402                                                        {
4403                                                          if (((word >> 0) & 0x1) == 0)
4404                                                            {
4405                                                              /* 33222222222211111111110000000000
4406                                                                 10987654321098765432109876543210
4407                                                                 x1000001xx1xxxxx110011xxxxxxxxx0
4408                                                                 sclamp.  */
4409                                                              return 2683;
4410                                                            }
4411                                                          else
4412                                                            {
4413                                                              /* 33222222222211111111110000000000
4414                                                                 10987654321098765432109876543210
4415                                                                 x1000001xx1xxxxx110011xxxxxxxxx1
4416                                                                 uclamp.  */
4417                                                              return 2848;
4418                                                            }
4419                                                        }
4420                                                      else
4421                                                        {
4422                                                          if (((word >> 5) & 0x1) == 0)
4423                                                            {
4424                                                              if (((word >> 6) & 0x1) == 0)
4425                                                                {
4426                                                                  /* 33222222222211111111110000000000
4427                                                                     10987654321098765432109876543210
4428                                                                     x1000001xx1xxxxx110111xxx00xxxxx
4429                                                                     sqrshrn.  */
4430                                                                  return 2754;
4431                                                                }
4432                                                              else
4433                                                                {
4434                                                                  /* 33222222222211111111110000000000
4435                                                                     10987654321098765432109876543210
4436                                                                     x1000001xx1xxxxx110111xxx10xxxxx
4437                                                                     sqrshrun.  */
4438                                                                  return 2757;
4439                                                                }
4440                                                            }
4441                                                          else
4442                                                            {
4443                                                              /* 33222222222211111111110000000000
4444                                                                 10987654321098765432109876543210
4445                                                                 x1000001xx1xxxxx110111xxxx1xxxxx
4446                                                                 uqrshrn.  */
4447                                                              return 2910;
4448                                                            }
4449                                                        }
4450                                                    }
4451                                                }
4452                                            }
4453                                        }
4454                                      else
4455                                        {
4456                                          if (((word >> 10) & 0x1) == 0)
4457                                            {
4458                                              if (((word >> 11) & 0x1) == 0)
4459                                                {
4460                                                  if (((word >> 12) & 0x1) == 0)
4461                                                    {
4462                                                      if (((word >> 14) & 0x1) == 0)
4463                                                        {
4464                                                          if (((word >> 0) & 0x1) == 0)
4465                                                            {
4466                                                              if (((word >> 5) & 0x1) == 0)
4467                                                                {
4468                                                                  if (((word >> 8) & 0x1) == 0)
4469                                                                    {
4470                                                                      /* 33222222222211111111110000000000
4471                                                                         10987654321098765432109876543210
4472                                                                         x1000001xx1xxxxx101000x0xx0xxxx0
4473                                                                         smax.  */
4474                                                                      return 2700;
4475                                                                    }
4476                                                                  else
4477                                                                    {
4478                                                                      if (((word >> 9) & 0x1) == 0)
4479                                                                        {
4480                                                                          /* 33222222222211111111110000000000
4481                                                                             10987654321098765432109876543210
4482                                                                             x1000001xx1xxxxx10100001xx0xxxx0
4483                                                                             fmax.  */
4484                                                                          return 2535;
4485                                                                        }
4486                                                                      else
4487                                                                        {
4488                                                                          /* 33222222222211111111110000000000
4489                                                                             10987654321098765432109876543210
4490                                                                             x1000001xx1xxxxx10100011xx0xxxx0
4491                                                                             add.  */
4492                                                                          return 2489;
4493                                                                        }
4494                                                                    }
4495                                                                }
4496                                                              else
4497                                                                {
4498                                                                  if (((word >> 8) & 0x1) == 0)
4499                                                                    {
4500                                                                      if (((word >> 9) & 0x1) == 0)
4501                                                                        {
4502                                                                          /* 33222222222211111111110000000000
4503                                                                             10987654321098765432109876543210
4504                                                                             x1000001xx1xxxxx10100000xx1xxxx0
4505                                                                             smin.  */
4506                                                                          return 2704;
4507                                                                        }
4508                                                                      else
4509                                                                        {
4510                                                                          /* 33222222222211111111110000000000
4511                                                                             10987654321098765432109876543210
4512                                                                             x1000001xx1xxxxx10100010xx1xxxx0
4513                                                                             srshl.  */
4514                                                                          return 2758;
4515                                                                        }
4516                                                                    }
4517                                                                  else
4518                                                                    {
4519                                                                      /* 33222222222211111111110000000000
4520                                                                         10987654321098765432109876543210
4521                                                                         x1000001xx1xxxxx101000x1xx1xxxx0
4522                                                                         fmaxnm.  */
4523                                                                      return 2539;
4524                                                                    }
4525                                                                }
4526                                                            }
4527                                                          else
4528                                                            {
4529                                                              if (((word >> 5) & 0x1) == 0)
4530                                                                {
4531                                                                  if (((word >> 8) & 0x1) == 0)
4532                                                                    {
4533                                                                      /* 33222222222211111111110000000000
4534                                                                         10987654321098765432109876543210
4535                                                                         x1000001xx1xxxxx101000x0xx0xxxx1
4536                                                                         umax.  */
4537                                                                      return 2863;
4538                                                                    }
4539                                                                  else
4540                                                                    {
4541                                                                      /* 33222222222211111111110000000000
4542                                                                         10987654321098765432109876543210
4543                                                                         x1000001xx1xxxxx101000x1xx0xxxx1
4544                                                                         fmin.  */
4545                                                                      return 2543;
4546                                                                    }
4547                                                                }
4548                                                              else
4549                                                                {
4550                                                                  if (((word >> 8) & 0x1) == 0)
4551                                                                    {
4552                                                                      if (((word >> 9) & 0x1) == 0)
4553                                                                        {
4554                                                                          /* 33222222222211111111110000000000
4555                                                                             10987654321098765432109876543210
4556                                                                             x1000001xx1xxxxx10100000xx1xxxx1
4557                                                                             umin.  */
4558                                                                          return 2867;
4559                                                                        }
4560                                                                      else
4561                                                                        {
4562                                                                          /* 33222222222211111111110000000000
4563                                                                             10987654321098765432109876543210
4564                                                                             x1000001xx1xxxxx10100010xx1xxxx1
4565                                                                             urshl.  */
4566                                                                          return 2911;
4567                                                                        }
4568                                                                    }
4569                                                                  else
4570                                                                    {
4571                                                                      /* 33222222222211111111110000000000
4572                                                                         10987654321098765432109876543210
4573                                                                         x1000001xx1xxxxx101000x1xx1xxxx1
4574                                                                         fminnm.  */
4575                                                                      return 2547;
4576                                                                    }
4577                                                                }
4578                                                            }
4579                                                        }
4580                                                      else
4581                                                        {
4582                                                          if (((word >> 16) & 0x1) == 0)
4583                                                            {
4584                                                              if (((word >> 5) & 0x1) == 0)
4585                                                                {
4586                                                                  if (((word >> 17) & 0x1) == 0)
4587                                                                    {
4588                                                                      if (((word >> 18) & 0x1) == 0)
4589                                                                        {
4590                                                                          if (((word >> 19) & 0x1) == 0)
4591                                                                            {
4592                                                                              if (((word >> 22) & 0x1) == 0)
4593                                                                                {
4594                                                                                  /* 33222222222211111111110000000000
4595                                                                                     10987654321098765432109876543210
4596                                                                                     x1000001x01x0000111000xxxx0xxxxx
4597                                                                                     fcvt.  */
4598                                                                                  return 2523;
4599                                                                                }
4600                                                                              else
4601                                                                                {
4602                                                                                  /* 33222222222211111111110000000000
4603                                                                                     10987654321098765432109876543210
4604                                                                                     x1000001x11x0000111000xxxx0xxxxx
4605                                                                                     bfcvt.  */
4606                                                                                  return 2491;
4607                                                                                }
4608                                                                            }
4609                                                                          else
4610                                                                            {
4611                                                                              if (((word >> 20) & 0x1) == 0)
4612                                                                                {
4613                                                                                  /* 33222222222211111111110000000000
4614                                                                                     10987654321098765432109876543210
4615                                                                                     x1000001xx101000111000xxxx0xxxxx
4616                                                                                     frintn.  */
4617                                                                                  return 2583;
4618                                                                                }
4619                                                                              else
4620                                                                                {
4621                                                                                  /* 33222222222211111111110000000000
4622                                                                                     10987654321098765432109876543210
4623                                                                                     x1000001xx111000111000xxxx0xxxxx
4624                                                                                     frintn.  */
4625                                                                                  return 2584;
4626                                                                                }
4627                                                                            }
4628                                                                        }
4629                                                                      else
4630                                                                        {
4631                                                                          if (((word >> 20) & 0x1) == 0)
4632                                                                            {
4633                                                                              /* 33222222222211111111110000000000
4634                                                                                 10987654321098765432109876543210
4635                                                                                 x1000001xx10x100111000xxxx0xxxxx
4636                                                                                 frinta.  */
4637                                                                              return 2579;
4638                                                                            }
4639                                                                          else
4640                                                                            {
4641                                                                              /* 33222222222211111111110000000000
4642                                                                                 10987654321098765432109876543210
4643                                                                                 x1000001xx11x100111000xxxx0xxxxx
4644                                                                                 frinta.  */
4645                                                                              return 2580;
4646                                                                            }
4647                                                                        }
4648                                                                    }
4649                                                                  else
4650                                                                    {
4651                                                                      if (((word >> 18) & 0x1) == 0)
4652                                                                        {
4653                                                                          if (((word >> 19) & 0x1) == 0)
4654                                                                            {
4655                                                                              if (((word >> 20) & 0x1) == 0)
4656                                                                                {
4657                                                                                  /* 33222222222211111111110000000000
4658                                                                                     10987654321098765432109876543210
4659                                                                                     x1000001xx100010111000xxxx0xxxxx
4660                                                                                     scvtf.  */
4661                                                                                  return 2684;
4662                                                                                }
4663                                                                              else
4664                                                                                {
4665                                                                                  /* 33222222222211111111110000000000
4666                                                                                     10987654321098765432109876543210
4667                                                                                     x1000001xx110010111000xxxx0xxxxx
4668                                                                                     scvtf.  */
4669                                                                                  return 2685;
4670                                                                                }
4671                                                                            }
4672                                                                          else
4673                                                                            {
4674                                                                              if (((word >> 20) & 0x1) == 0)
4675                                                                                {
4676                                                                                  /* 33222222222211111111110000000000
4677                                                                                     10987654321098765432109876543210
4678                                                                                     x1000001xx101010111000xxxx0xxxxx
4679                                                                                     frintm.  */
4680                                                                                  return 2581;
4681                                                                                }
4682                                                                              else
4683                                                                                {
4684                                                                                  /* 33222222222211111111110000000000
4685                                                                                     10987654321098765432109876543210
4686                                                                                     x1000001xx111010111000xxxx0xxxxx
4687                                                                                     frintm.  */
4688                                                                                  return 2582;
4689                                                                                }
4690                                                                            }
4691                                                                        }
4692                                                                      else
4693                                                                        {
4694                                                                          if (((word >> 1) & 0x1) == 0)
4695                                                                            {
4696                                                                              /* 33222222222211111111110000000000
4697                                                                                 10987654321098765432109876543210
4698                                                                                 x1000001xx1xx110111000xxxx0xxx0x
4699                                                                                 zip.  */
4700                                                                              return 2949;
4701                                                                            }
4702                                                                          else
4703                                                                            {
4704                                                                              /* 33222222222211111111110000000000
4705                                                                                 10987654321098765432109876543210
4706                                                                                 x1000001xx1xx110111000xxxx0xxx1x
4707                                                                                 uzp.  */
4708                                                                              return 2936;
4709                                                                            }
4710                                                                        }
4711                                                                    }
4712                                                                }
4713                                                              else
4714                                                                {
4715                                                                  if (((word >> 17) & 0x1) == 0)
4716                                                                    {
4717                                                                      if (((word >> 22) & 0x1) == 0)
4718                                                                        {
4719                                                                          /* 33222222222211111111110000000000
4720                                                                             10987654321098765432109876543210
4721                                                                             x1000001x01xxx00111000xxxx1xxxxx
4722                                                                             fcvtn.  */
4723                                                                          return 2524;
4724                                                                        }
4725                                                                      else
4726                                                                        {
4727                                                                          /* 33222222222211111111110000000000
4728                                                                             10987654321098765432109876543210
4729                                                                             x1000001x11xxx00111000xxxx1xxxxx
4730                                                                             bfcvtn.  */
4731                                                                          return 2492;
4732                                                                        }
4733                                                                    }
4734                                                                  else
4735                                                                    {
4736                                                                      if (((word >> 20) & 0x1) == 0)
4737                                                                        {
4738                                                                          /* 33222222222211111111110000000000
4739                                                                             10987654321098765432109876543210
4740                                                                             x1000001xx10xx10111000xxxx1xxxxx
4741                                                                             ucvtf.  */
4742                                                                          return 2849;
4743                                                                        }
4744                                                                      else
4745                                                                        {
4746                                                                          /* 33222222222211111111110000000000
4747                                                                             10987654321098765432109876543210
4748                                                                             x1000001xx11xx10111000xxxx1xxxxx
4749                                                                             ucvtf.  */
4750                                                                          return 2850;
4751                                                                        }
4752                                                                    }
4753                                                                }
4754                                                            }
4755                                                          else
4756                                                            {
4757                                                              if (((word >> 17) & 0x1) == 0)
4758                                                                {
4759                                                                  if (((word >> 0) & 0x1) == 0)
4760                                                                    {
4761                                                                      if (((word >> 18) & 0x1) == 0)
4762                                                                        {
4763                                                                          if (((word >> 5) & 0x1) == 0)
4764                                                                            {
4765                                                                              if (((word >> 19) & 0x1) == 0)
4766                                                                                {
4767                                                                                  if (((word >> 20) & 0x1) == 0)
4768                                                                                    {
4769                                                                                      /* 33222222222211111111110000000000
4770                                                                                         10987654321098765432109876543210
4771                                                                                         x1000001xx100001111000xxxx0xxxx0
4772                                                                                         fcvtzs.  */
4773                                                                                      return 2525;
4774                                                                                    }
4775                                                                                  else
4776                                                                                    {
4777                                                                                      /* 33222222222211111111110000000000
4778                                                                                         10987654321098765432109876543210
4779                                                                                         x1000001xx110001111000xxxx0xxxx0
4780                                                                                         fcvtzs.  */
4781                                                                                      return 2526;
4782                                                                                    }
4783                                                                                }
4784                                                                              else
4785                                                                                {
4786                                                                                  if (((word >> 20) & 0x1) == 0)
4787                                                                                    {
4788                                                                                      /* 33222222222211111111110000000000
4789                                                                                         10987654321098765432109876543210
4790                                                                                         x1000001xx101001111000xxxx0xxxx0
4791                                                                                         frintp.  */
4792                                                                                      return 2585;
4793                                                                                    }
4794                                                                                  else
4795                                                                                    {
4796                                                                                      /* 33222222222211111111110000000000
4797                                                                                         10987654321098765432109876543210
4798                                                                                         x1000001xx111001111000xxxx0xxxx0
4799                                                                                         frintp.  */
4800                                                                                      return 2586;
4801                                                                                    }
4802                                                                                }
4803                                                                            }
4804                                                                          else
4805                                                                            {
4806                                                                              if (((word >> 20) & 0x1) == 0)
4807                                                                                {
4808                                                                                  /* 33222222222211111111110000000000
4809                                                                                     10987654321098765432109876543210
4810                                                                                     x1000001xx10x001111000xxxx1xxxx0
4811                                                                                     fcvtzu.  */
4812                                                                                  return 2527;
4813                                                                                }
4814                                                                              else
4815                                                                                {
4816                                                                                  /* 33222222222211111111110000000000
4817                                                                                     10987654321098765432109876543210
4818                                                                                     x1000001xx11x001111000xxxx1xxxx0
4819                                                                                     fcvtzu.  */
4820                                                                                  return 2528;
4821                                                                                }
4822                                                                            }
4823                                                                        }
4824                                                                      else
4825                                                                        {
4826                                                                          if (((word >> 20) & 0x1) == 0)
4827                                                                            {
4828                                                                              /* 33222222222211111111110000000000
4829                                                                                 10987654321098765432109876543210
4830                                                                                 x1000001xx10x101111000xxxxxxxxx0
4831                                                                                 sunpk.  */
4832                                                                              return 2842;
4833                                                                            }
4834                                                                          else
4835                                                                            {
4836                                                                              /* 33222222222211111111110000000000
4837                                                                                 10987654321098765432109876543210
4838                                                                                 x1000001xx11x101111000xxxxxxxxx0
4839                                                                                 sunpk.  */
4840                                                                              return 2843;
4841                                                                            }
4842                                                                        }
4843                                                                    }
4844                                                                  else
4845                                                                    {
4846                                                                      if (((word >> 20) & 0x1) == 0)
4847                                                                        {
4848                                                                          /* 33222222222211111111110000000000
4849                                                                             10987654321098765432109876543210
4850                                                                             x1000001xx10xx01111000xxxxxxxxx1
4851                                                                             uunpk.  */
4852                                                                          return 2930;
4853                                                                        }
4854                                                                      else
4855                                                                        {
4856                                                                          /* 33222222222211111111110000000000
4857                                                                             10987654321098765432109876543210
4858                                                                             x1000001xx11xx01111000xxxxxxxxx1
4859                                                                             uunpk.  */
4860                                                                          return 2931;
4861                                                                        }
4862                                                                    }
4863                                                                }
4864                                                              else
4865                                                                {
4866                                                                  if (((word >> 5) & 0x1) == 0)
4867                                                                    {
4868                                                                      if (((word >> 18) & 0x1) == 0)
4869                                                                        {
4870                                                                          if (((word >> 20) & 0x1) == 0)
4871                                                                            {
4872                                                                              if (((word >> 22) & 0x1) == 0)
4873                                                                                {
4874                                                                                  /* 33222222222211111111110000000000
4875                                                                                     10987654321098765432109876543210
4876                                                                                     x1000001x010x011111000xxxx0xxxxx
4877                                                                                     sqcvt.  */
4878                                                                                  return 2742;
4879                                                                                }
4880                                                                              else
4881                                                                                {
4882                                                                                  /* 33222222222211111111110000000000
4883                                                                                     10987654321098765432109876543210
4884                                                                                     x1000001x110x011111000xxxx0xxxxx
4885                                                                                     sqcvtu.  */
4886                                                                                  return 2745;
4887                                                                                }
4888                                                                            }
4889                                                                          else
4890                                                                            {
4891                                                                              if (((word >> 6) & 0x1) == 0)
4892                                                                                {
4893                                                                                  if (((word >> 22) & 0x1) == 0)
4894                                                                                    {
4895                                                                                      /* 33222222222211111111110000000000
4896                                                                                         10987654321098765432109876543210
4897                                                                                         x1000001x011x011111000xxx00xxxxx
4898                                                                                         sqcvt.  */
4899                                                                                      return 2743;
4900                                                                                    }
4901                                                                                  else
4902                                                                                    {
4903                                                                                      /* 33222222222211111111110000000000
4904                                                                                         10987654321098765432109876543210
4905                                                                                         x1000001x111x011111000xxx00xxxxx
4906                                                                                         sqcvtu.  */
4907                                                                                      return 2746;
4908                                                                                    }
4909                                                                                }
4910                                                                              else
4911                                                                                {
4912                                                                                  if (((word >> 22) & 0x1) == 0)
4913                                                                                    {
4914                                                                                      /* 33222222222211111111110000000000
4915                                                                                         10987654321098765432109876543210
4916                                                                                         x1000001x011x011111000xxx10xxxxx
4917                                                                                         sqcvtn.  */
4918                                                                                      return 2744;
4919                                                                                    }
4920                                                                                  else
4921                                                                                    {
4922                                                                                      /* 33222222222211111111110000000000
4923                                                                                         10987654321098765432109876543210
4924                                                                                         x1000001x111x011111000xxx10xxxxx
4925                                                                                         sqcvtun.  */
4926                                                                                      return 2747;
4927                                                                                    }
4928                                                                                }
4929                                                                            }
4930                                                                        }
4931                                                                      else
4932                                                                        {
4933                                                                          if (((word >> 1) & 0x1) == 0)
4934                                                                            {
4935                                                                              /* 33222222222211111111110000000000
4936                                                                                 10987654321098765432109876543210
4937                                                                                 x1000001xx1xx111111000xxxx0xxx0x
4938                                                                                 zip.  */
4939                                                                              return 2950;
4940                                                                            }
4941                                                                          else
4942                                                                            {
4943                                                                              /* 33222222222211111111110000000000
4944                                                                                 10987654321098765432109876543210
4945                                                                                 x1000001xx1xx111111000xxxx0xxx1x
4946                                                                                 uzp.  */
4947                                                                              return 2937;
4948                                                                            }
4949                                                                        }
4950                                                                    }
4951                                                                  else
4952                                                                    {
4953                                                                      if (((word >> 20) & 0x1) == 0)
4954                                                                        {
4955                                                                          /* 33222222222211111111110000000000
4956                                                                             10987654321098765432109876543210
4957                                                                             x1000001xx10xx11111000xxxx1xxxxx
4958                                                                             uqcvt.  */
4959                                                                          return 2905;
4960                                                                        }
4961                                                                      else
4962                                                                        {
4963                                                                          if (((word >> 6) & 0x1) == 0)
4964                                                                            {
4965                                                                              /* 33222222222211111111110000000000
4966                                                                                 10987654321098765432109876543210
4967                                                                                 x1000001xx11xx11111000xxx01xxxxx
4968                                                                                 uqcvt.  */
4969                                                                              return 2906;
4970                                                                            }
4971                                                                          else
4972                                                                            {
4973                                                                              /* 33222222222211111111110000000000
4974                                                                                 10987654321098765432109876543210
4975                                                                                 x1000001xx11xx11111000xxx11xxxxx
4976                                                                                 uqcvtn.  */
4977                                                                              return 2907;
4978                                                                            }
4979                                                                        }
4980                                                                    }
4981                                                                }
4982                                                            }
4983                                                        }
4984                                                    }
4985                                                  else
4986                                                    {
4987                                                      if (((word >> 0) & 0x1) == 0)
4988                                                        {
4989                                                          if (((word >> 5) & 0x1) == 0)
4990                                                            {
4991                                                              if (((word >> 8) & 0x1) == 0)
4992                                                                {
4993                                                                  /* 33222222222211111111110000000000
4994                                                                     10987654321098765432109876543210
4995                                                                     x1000001xx1xxxxx1x1100x0xx0xxxx0
4996                                                                     smax.  */
4997                                                                  return 2702;
4998                                                                }
4999                                                              else
5000                                                                {
5001                                                                  /* 33222222222211111111110000000000
5002                                                                     10987654321098765432109876543210
5003                                                                     x1000001xx1xxxxx1x1100x1xx0xxxx0
5004                                                                     fmax.  */
5005                                                                  return 2537;
5006                                                                }
5007                                                            }
5008                                                          else
5009                                                            {
5010                                                              if (((word >> 8) & 0x1) == 0)
5011                                                                {
5012                                                                  if (((word >> 9) & 0x1) == 0)
5013                                                                    {
5014                                                                      /* 33222222222211111111110000000000
5015                                                                         10987654321098765432109876543210
5016                                                                         x1000001xx1xxxxx1x110000xx1xxxx0
5017                                                                         smin.  */
5018                                                                      return 2706;
5019                                                                    }
5020                                                                  else
5021                                                                    {
5022                                                                      /* 33222222222211111111110000000000
5023                                                                         10987654321098765432109876543210
5024                                                                         x1000001xx1xxxxx1x110010xx1xxxx0
5025                                                                         srshl.  */
5026                                                                      return 2760;
5027                                                                    }
5028                                                                }
5029                                                              else
5030                                                                {
5031                                                                  /* 33222222222211111111110000000000
5032                                                                     10987654321098765432109876543210
5033                                                                     x1000001xx1xxxxx1x1100x1xx1xxxx0
5034                                                                     fmaxnm.  */
5035                                                                  return 2541;
5036                                                                }
5037                                                            }
5038                                                        }
5039                                                      else
5040                                                        {
5041                                                          if (((word >> 5) & 0x1) == 0)
5042                                                            {
5043                                                              if (((word >> 8) & 0x1) == 0)
5044                                                                {
5045                                                                  /* 33222222222211111111110000000000
5046                                                                     10987654321098765432109876543210
5047                                                                     x1000001xx1xxxxx1x1100x0xx0xxxx1
5048                                                                     umax.  */
5049                                                                  return 2865;
5050                                                                }
5051                                                              else
5052                                                                {
5053                                                                  /* 33222222222211111111110000000000
5054                                                                     10987654321098765432109876543210
5055                                                                     x1000001xx1xxxxx1x1100x1xx0xxxx1
5056                                                                     fmin.  */
5057                                                                  return 2545;
5058                                                                }
5059                                                            }
5060                                                          else
5061                                                            {
5062                                                              if (((word >> 8) & 0x1) == 0)
5063                                                                {
5064                                                                  if (((word >> 9) & 0x1) == 0)
5065                                                                    {
5066                                                                      /* 33222222222211111111110000000000
5067                                                                         10987654321098765432109876543210
5068                                                                         x1000001xx1xxxxx1x110000xx1xxxx1
5069                                                                         umin.  */
5070                                                                      return 2869;
5071                                                                    }
5072                                                                  else
5073                                                                    {
5074                                                                      /* 33222222222211111111110000000000
5075                                                                         10987654321098765432109876543210
5076                                                                         x1000001xx1xxxxx1x110010xx1xxxx1
5077                                                                         urshl.  */
5078                                                                      return 2913;
5079                                                                    }
5080                                                                }
5081                                                              else
5082                                                                {
5083                                                                  /* 33222222222211111111110000000000
5084                                                                     10987654321098765432109876543210
5085                                                                     x1000001xx1xxxxx1x1100x1xx1xxxx1
5086                                                                     fminnm.  */
5087                                                                  return 2549;
5088                                                                }
5089                                                            }
5090                                                        }
5091                                                    }
5092                                                }
5093                                              else
5094                                                {
5095                                                  if (((word >> 0) & 0x1) == 0)
5096                                                    {
5097                                                      if (((word >> 5) & 0x1) == 0)
5098                                                        {
5099                                                          if (((word >> 8) & 0x1) == 0)
5100                                                            {
5101                                                              if (((word >> 12) & 0x1) == 0)
5102                                                                {
5103                                                                  /* 33222222222211111111110000000000
5104                                                                     10987654321098765432109876543210
5105                                                                     x1000001xx1xxxxx1x1010x0xx0xxxx0
5106                                                                     smax.  */
5107                                                                  return 2701;
5108                                                                }
5109                                                              else
5110                                                                {
5111                                                                  /* 33222222222211111111110000000000
5112                                                                     10987654321098765432109876543210
5113                                                                     x1000001xx1xxxxx1x1110x0xx0xxxx0
5114                                                                     smax.  */
5115                                                                  return 2703;
5116                                                                }
5117                                                            }
5118                                                          else
5119                                                            {
5120                                                              if (((word >> 9) & 0x1) == 0)
5121                                                                {
5122                                                                  if (((word >> 12) & 0x1) == 0)
5123                                                                    {
5124                                                                      /* 33222222222211111111110000000000
5125                                                                         10987654321098765432109876543210
5126                                                                         x1000001xx1xxxxx1x101001xx0xxxx0
5127                                                                         fmax.  */
5128                                                                      return 2536;
5129                                                                    }
5130                                                                  else
5131                                                                    {
5132                                                                      /* 33222222222211111111110000000000
5133                                                                         10987654321098765432109876543210
5134                                                                         x1000001xx1xxxxx1x111001xx0xxxx0
5135                                                                         fmax.  */
5136                                                                      return 2538;
5137                                                                    }
5138                                                                }
5139                                                              else
5140                                                                {
5141                                                                  /* 33222222222211111111110000000000
5142                                                                     10987654321098765432109876543210
5143                                                                     x1000001xx1xxxxx1x1x1011xx0xxxx0
5144                                                                     add.  */
5145                                                                  return 2490;
5146                                                                }
5147                                                            }
5148                                                        }
5149                                                      else
5150                                                        {
5151                                                          if (((word >> 8) & 0x1) == 0)
5152                                                            {
5153                                                              if (((word >> 9) & 0x1) == 0)
5154                                                                {
5155                                                                  if (((word >> 12) & 0x1) == 0)
5156                                                                    {
5157                                                                      /* 33222222222211111111110000000000
5158                                                                         10987654321098765432109876543210
5159                                                                         x1000001xx1xxxxx1x101000xx1xxxx0
5160                                                                         smin.  */
5161                                                                      return 2705;
5162                                                                    }
5163                                                                  else
5164                                                                    {
5165                                                                      /* 33222222222211111111110000000000
5166                                                                         10987654321098765432109876543210
5167                                                                         x1000001xx1xxxxx1x111000xx1xxxx0
5168                                                                         smin.  */
5169                                                                      return 2707;
5170                                                                    }
5171                                                                }
5172                                                              else
5173                                                                {
5174                                                                  if (((word >> 12) & 0x1) == 0)
5175                                                                    {
5176                                                                      /* 33222222222211111111110000000000
5177                                                                         10987654321098765432109876543210
5178                                                                         x1000001xx1xxxxx1x101010xx1xxxx0
5179                                                                         srshl.  */
5180                                                                      return 2759;
5181                                                                    }
5182                                                                  else
5183                                                                    {
5184                                                                      /* 33222222222211111111110000000000
5185                                                                         10987654321098765432109876543210
5186                                                                         x1000001xx1xxxxx1x111010xx1xxxx0
5187                                                                         srshl.  */
5188                                                                      return 2761;
5189                                                                    }
5190                                                                }
5191                                                            }
5192                                                          else
5193                                                            {
5194                                                              if (((word >> 12) & 0x1) == 0)
5195                                                                {
5196                                                                  /* 33222222222211111111110000000000
5197                                                                     10987654321098765432109876543210
5198                                                                     x1000001xx1xxxxx1x1010x1xx1xxxx0
5199                                                                     fmaxnm.  */
5200                                                                  return 2540;
5201                                                                }
5202                                                              else
5203                                                                {
5204                                                                  /* 33222222222211111111110000000000
5205                                                                     10987654321098765432109876543210
5206                                                                     x1000001xx1xxxxx1x1110x1xx1xxxx0
5207                                                                     fmaxnm.  */
5208                                                                  return 2542;
5209                                                                }
5210                                                            }
5211                                                        }
5212                                                    }
5213                                                  else
5214                                                    {
5215                                                      if (((word >> 5) & 0x1) == 0)
5216                                                        {
5217                                                          if (((word >> 8) & 0x1) == 0)
5218                                                            {
5219                                                              if (((word >> 12) & 0x1) == 0)
5220                                                                {
5221                                                                  /* 33222222222211111111110000000000
5222                                                                     10987654321098765432109876543210
5223                                                                     x1000001xx1xxxxx1x1010x0xx0xxxx1
5224                                                                     umax.  */
5225                                                                  return 2864;
5226                                                                }
5227                                                              else
5228                                                                {
5229                                                                  /* 33222222222211111111110000000000
5230                                                                     10987654321098765432109876543210
5231                                                                     x1000001xx1xxxxx1x1110x0xx0xxxx1
5232                                                                     umax.  */
5233                                                                  return 2866;
5234                                                                }
5235                                                            }
5236                                                          else
5237                                                            {
5238                                                              if (((word >> 12) & 0x1) == 0)
5239                                                                {
5240                                                                  /* 33222222222211111111110000000000
5241                                                                     10987654321098765432109876543210
5242                                                                     x1000001xx1xxxxx1x1010x1xx0xxxx1
5243                                                                     fmin.  */
5244                                                                  return 2544;
5245                                                                }
5246                                                              else
5247                                                                {
5248                                                                  /* 33222222222211111111110000000000
5249                                                                     10987654321098765432109876543210
5250                                                                     x1000001xx1xxxxx1x1110x1xx0xxxx1
5251                                                                     fmin.  */
5252                                                                  return 2546;
5253                                                                }
5254                                                            }
5255                                                        }
5256                                                      else
5257                                                        {
5258                                                          if (((word >> 8) & 0x1) == 0)
5259                                                            {
5260                                                              if (((word >> 9) & 0x1) == 0)
5261                                                                {
5262                                                                  if (((word >> 12) & 0x1) == 0)
5263                                                                    {
5264                                                                      /* 33222222222211111111110000000000
5265                                                                         10987654321098765432109876543210
5266                                                                         x1000001xx1xxxxx1x101000xx1xxxx1
5267                                                                         umin.  */
5268                                                                      return 2868;
5269                                                                    }
5270                                                                  else
5271                                                                    {
5272                                                                      /* 33222222222211111111110000000000
5273                                                                         10987654321098765432109876543210
5274                                                                         x1000001xx1xxxxx1x111000xx1xxxx1
5275                                                                         umin.  */
5276                                                                      return 2870;
5277                                                                    }
5278                                                                }
5279                                                              else
5280                                                                {
5281                                                                  if (((word >> 12) & 0x1) == 0)
5282                                                                    {
5283                                                                      /* 33222222222211111111110000000000
5284                                                                         10987654321098765432109876543210
5285                                                                         x1000001xx1xxxxx1x101010xx1xxxx1
5286                                                                         urshl.  */
5287                                                                      return 2912;
5288                                                                    }
5289                                                                  else
5290                                                                    {
5291                                                                      /* 33222222222211111111110000000000
5292                                                                         10987654321098765432109876543210
5293                                                                         x1000001xx1xxxxx1x111010xx1xxxx1
5294                                                                         urshl.  */
5295                                                                      return 2914;
5296                                                                    }
5297                                                                }
5298                                                            }
5299                                                          else
5300                                                            {
5301                                                              if (((word >> 12) & 0x1) == 0)
5302                                                                {
5303                                                                  /* 33222222222211111111110000000000
5304                                                                     10987654321098765432109876543210
5305                                                                     x1000001xx1xxxxx1x1010x1xx1xxxx1
5306                                                                     fminnm.  */
5307                                                                  return 2548;
5308                                                                }
5309                                                              else
5310                                                                {
5311                                                                  /* 33222222222211111111110000000000
5312                                                                     10987654321098765432109876543210
5313                                                                     x1000001xx1xxxxx1x1110x1xx1xxxx1
5314                                                                     fminnm.  */
5315                                                                  return 2550;
5316                                                                }
5317                                                            }
5318                                                        }
5319                                                    }
5320                                                }
5321                                            }
5322                                          else
5323                                            {
5324                                              if (((word >> 11) & 0x1) == 0)
5325                                                {
5326                                                  if (((word >> 12) & 0x1) == 0)
5327                                                    {
5328                                                      /* 33222222222211111111110000000000
5329                                                         10987654321098765432109876543210
5330                                                         x1000001xx1xxxxx1x1001xxxxxxxxxx
5331                                                         sqdmulh.  */
5332                                                      return 2748;
5333                                                    }
5334                                                  else
5335                                                    {
5336                                                      /* 33222222222211111111110000000000
5337                                                         10987654321098765432109876543210
5338                                                         x1000001xx1xxxxx1x1101xxxxxxxxxx
5339                                                         sqdmulh.  */
5340                                                      return 2750;
5341                                                    }
5342                                                }
5343                                              else
5344                                                {
5345                                                  if (((word >> 12) & 0x1) == 0)
5346                                                    {
5347                                                      /* 33222222222211111111110000000000
5348                                                         10987654321098765432109876543210
5349                                                         x1000001xx1xxxxx1x1011xxxxxxxxxx
5350                                                         sqdmulh.  */
5351                                                      return 2749;
5352                                                    }
5353                                                  else
5354                                                    {
5355                                                      /* 33222222222211111111110000000000
5356                                                         10987654321098765432109876543210
5357                                                         x1000001xx1xxxxx1x1111xxxxxxxxxx
5358                                                         sqdmulh.  */
5359                                                      return 2751;
5360                                                    }
5361                                                }
5362                                            }
5363                                        }
5364                                    }
5365                                }
5366                            }
5367                          else
5368                            {
5369                              if (((word >> 22) & 0x1) == 0)
5370                                {
5371                                  if (((word >> 23) & 0x1) == 0)
5372                                    {
5373                                      if (((word >> 15) & 0x1) == 0)
5374                                        {
5375                                          if (((word >> 30) & 0x1) == 0)
5376                                            {
5377                                              if (((word >> 3) & 0x1) == 0)
5378                                                {
5379                                                  if (((word >> 13) & 0x1) == 0)
5380                                                    {
5381                                                      if (((word >> 14) & 0x1) == 0)
5382                                                        {
5383                                                          /* 33222222222211111111110000000000
5384                                                             10987654321098765432109876543210
5385                                                             x0100001001xxxxx000xxxxxxxxx0xxx
5386                                                             st1b.  */
5387                                                          return 2768;
5388                                                        }
5389                                                      else
5390                                                        {
5391                                                          /* 33222222222211111111110000000000
5392                                                             10987654321098765432109876543210
5393                                                             x0100001001xxxxx010xxxxxxxxx0xxx
5394                                                             st1w.  */
5395                                                          return 2792;
5396                                                        }
5397                                                    }
5398                                                  else
5399                                                    {
5400                                                      if (((word >> 14) & 0x1) == 0)
5401                                                        {
5402                                                          /* 33222222222211111111110000000000
5403                                                             10987654321098765432109876543210
5404                                                             x0100001001xxxxx001xxxxxxxxx0xxx
5405                                                             st1h.  */
5406                                                          return 2784;
5407                                                        }
5408                                                      else
5409                                                        {
5410                                                          /* 33222222222211111111110000000000
5411                                                             10987654321098765432109876543210
5412                                                             x0100001001xxxxx011xxxxxxxxx0xxx
5413                                                             st1d.  */
5414                                                          return 2776;
5415                                                        }
5416                                                    }
5417                                                }
5418                                              else
5419                                                {
5420                                                  if (((word >> 13) & 0x1) == 0)
5421                                                    {
5422                                                      if (((word >> 14) & 0x1) == 0)
5423                                                        {
5424                                                          /* 33222222222211111111110000000000
5425                                                             10987654321098765432109876543210
5426                                                             x0100001001xxxxx000xxxxxxxxx1xxx
5427                                                             stnt1b.  */
5428                                                          return 2800;
5429                                                        }
5430                                                      else
5431                                                        {
5432                                                          /* 33222222222211111111110000000000
5433                                                             10987654321098765432109876543210
5434                                                             x0100001001xxxxx010xxxxxxxxx1xxx
5435                                                             stnt1w.  */
5436                                                          return 2824;
5437                                                        }
5438                                                    }
5439                                                  else
5440                                                    {
5441                                                      if (((word >> 14) & 0x1) == 0)
5442                                                        {
5443                                                          /* 33222222222211111111110000000000
5444                                                             10987654321098765432109876543210
5445                                                             x0100001001xxxxx001xxxxxxxxx1xxx
5446                                                             stnt1h.  */
5447                                                          return 2816;
5448                                                        }
5449                                                      else
5450                                                        {
5451                                                          /* 33222222222211111111110000000000
5452                                                             10987654321098765432109876543210
5453                                                             x0100001001xxxxx011xxxxxxxxx1xxx
5454                                                             stnt1d.  */
5455                                                          return 2808;
5456                                                        }
5457                                                    }
5458                                                }
5459                                            }
5460                                          else
5461                                            {
5462                                              /* 33222222222211111111110000000000
5463                                                 10987654321098765432109876543210
5464                                                 x1100001001xxxxx0xxxxxxxxxxxxxxx
5465                                                 str.  */
5466                                              return 2451;
5467                                            }
5468                                        }
5469                                      else
5470                                        {
5471                                          if (((word >> 3) & 0x1) == 0)
5472                                            {
5473                                              if (((word >> 13) & 0x1) == 0)
5474                                                {
5475                                                  if (((word >> 14) & 0x1) == 0)
5476                                                    {
5477                                                      if (((word >> 30) & 0x1) == 0)
5478                                                        {
5479                                                          /* 33222222222211111111110000000000
5480                                                             10987654321098765432109876543210
5481                                                             x0100001001xxxxx100xxxxxxxxx0xxx
5482                                                             st1b.  */
5483                                                          return 2769;
5484                                                        }
5485                                                      else
5486                                                        {
5487                                                          /* 33222222222211111111110000000000
5488                                                             10987654321098765432109876543210
5489                                                             x1100001001xxxxx100xxxxxxxxx0xxx
5490                                                             str.  */
5491                                                          return 2826;
5492                                                        }
5493                                                    }
5494                                                  else
5495                                                    {
5496                                                      /* 33222222222211111111110000000000
5497                                                         10987654321098765432109876543210
5498                                                         xx100001001xxxxx110xxxxxxxxx0xxx
5499                                                         st1w.  */
5500                                                      return 2793;
5501                                                    }
5502                                                }
5503                                              else
5504                                                {
5505                                                  if (((word >> 14) & 0x1) == 0)
5506                                                    {
5507                                                      /* 33222222222211111111110000000000
5508                                                         10987654321098765432109876543210
5509                                                         xx100001001xxxxx101xxxxxxxxx0xxx
5510                                                         st1h.  */
5511                                                      return 2785;
5512                                                    }
5513                                                  else
5514                                                    {
5515                                                      /* 33222222222211111111110000000000
5516                                                         10987654321098765432109876543210
5517                                                         xx100001001xxxxx111xxxxxxxxx0xxx
5518                                                         st1d.  */
5519                                                      return 2777;
5520                                                    }
5521                                                }
5522                                            }
5523                                          else
5524                                            {
5525                                              if (((word >> 13) & 0x1) == 0)
5526                                                {
5527                                                  if (((word >> 14) & 0x1) == 0)
5528                                                    {
5529                                                      /* 33222222222211111111110000000000
5530                                                         10987654321098765432109876543210
5531                                                         xx100001001xxxxx100xxxxxxxxx1xxx
5532                                                         stnt1b.  */
5533                                                      return 2801;
5534                                                    }
5535                                                  else
5536                                                    {
5537                                                      /* 33222222222211111111110000000000
5538                                                         10987654321098765432109876543210
5539                                                         xx100001001xxxxx110xxxxxxxxx1xxx
5540                                                         stnt1w.  */
5541                                                      return 2825;
5542                                                    }
5543                                                }
5544                                              else
5545                                                {
5546                                                  if (((word >> 14) & 0x1) == 0)
5547                                                    {
5548                                                      /* 33222222222211111111110000000000
5549                                                         10987654321098765432109876543210
5550                                                         xx100001001xxxxx101xxxxxxxxx1xxx
5551                                                         stnt1h.  */
5552                                                      return 2817;
5553                                                    }
5554                                                  else
5555                                                    {
5556                                                      /* 33222222222211111111110000000000
5557                                                         10987654321098765432109876543210
5558                                                         xx100001001xxxxx111xxxxxxxxx1xxx
5559                                                         stnt1d.  */
5560                                                      return 2809;
5561                                                    }
5562                                                }
5563                                            }
5564                                        }
5565                                    }
5566                                  else
5567                                    {
5568                                      if (((word >> 4) & 0x1) == 0)
5569                                        {
5570                                          /* 33222222222211111111110000000000
5571                                             10987654321098765432109876543210
5572                                             xx100001101xxxxxxxxxxxxxxxx0xxxx
5573                                             umopa.  */
5574                                          return 2417;
5575                                        }
5576                                      else
5577                                        {
5578                                          /* 33222222222211111111110000000000
5579                                             10987654321098765432109876543210
5580                                             xx100001101xxxxxxxxxxxxxxxx1xxxx
5581                                             umops.  */
5582                                          return 2419;
5583                                        }
5584                                    }
5585                                }
5586                              else
5587                                {
5588                                  if (((word >> 23) & 0x1) == 0)
5589                                    {
5590                                      if (((word >> 3) & 0x1) == 0)
5591                                        {
5592                                          if (((word >> 13) & 0x1) == 0)
5593                                            {
5594                                              if (((word >> 14) & 0x1) == 0)
5595                                                {
5596                                                  if (((word >> 15) & 0x1) == 0)
5597                                                    {
5598                                                      /* 33222222222211111111110000000000
5599                                                         10987654321098765432109876543210
5600                                                         xx100001011xxxxx000xxxxxxxxx0xxx
5601                                                         st1b.  */
5602                                                      return 2764;
5603                                                    }
5604                                                  else
5605                                                    {
5606                                                      /* 33222222222211111111110000000000
5607                                                         10987654321098765432109876543210
5608                                                         xx100001011xxxxx100xxxxxxxxx0xxx
5609                                                         st1b.  */
5610                                                      return 2765;
5611                                                    }
5612                                                }
5613                                              else
5614                                                {
5615                                                  if (((word >> 15) & 0x1) == 0)
5616                                                    {
5617                                                      /* 33222222222211111111110000000000
5618                                                         10987654321098765432109876543210
5619                                                         xx100001011xxxxx010xxxxxxxxx0xxx
5620                                                         st1w.  */
5621                                                      return 2788;
5622                                                    }
5623                                                  else
5624                                                    {
5625                                                      /* 33222222222211111111110000000000
5626                                                         10987654321098765432109876543210
5627                                                         xx100001011xxxxx110xxxxxxxxx0xxx
5628                                                         st1w.  */
5629                                                      return 2789;
5630                                                    }
5631                                                }
5632                                            }
5633                                          else
5634                                            {
5635                                              if (((word >> 14) & 0x1) == 0)
5636                                                {
5637                                                  if (((word >> 15) & 0x1) == 0)
5638                                                    {
5639                                                      /* 33222222222211111111110000000000
5640                                                         10987654321098765432109876543210
5641                                                         xx100001011xxxxx001xxxxxxxxx0xxx
5642                                                         st1h.  */
5643                                                      return 2780;
5644                                                    }
5645                                                  else
5646                                                    {
5647                                                      /* 33222222222211111111110000000000
5648                                                         10987654321098765432109876543210
5649                                                         xx100001011xxxxx101xxxxxxxxx0xxx
5650                                                         st1h.  */
5651                                                      return 2781;
5652                                                    }
5653                                                }
5654                                              else
5655                                                {
5656                                                  if (((word >> 15) & 0x1) == 0)
5657                                                    {
5658                                                      /* 33222222222211111111110000000000
5659                                                         10987654321098765432109876543210
5660                                                         xx100001011xxxxx011xxxxxxxxx0xxx
5661                                                         st1d.  */
5662                                                      return 2772;
5663                                                    }
5664                                                  else
5665                                                    {
5666                                                      /* 33222222222211111111110000000000
5667                                                         10987654321098765432109876543210
5668                                                         xx100001011xxxxx111xxxxxxxxx0xxx
5669                                                         st1d.  */
5670                                                      return 2773;
5671                                                    }
5672                                                }
5673                                            }
5674                                        }
5675                                      else
5676                                        {
5677                                          if (((word >> 13) & 0x1) == 0)
5678                                            {
5679                                              if (((word >> 14) & 0x1) == 0)
5680                                                {
5681                                                  if (((word >> 15) & 0x1) == 0)
5682                                                    {
5683                                                      /* 33222222222211111111110000000000
5684                                                         10987654321098765432109876543210
5685                                                         xx100001011xxxxx000xxxxxxxxx1xxx
5686                                                         stnt1b.  */
5687                                                      return 2796;
5688                                                    }
5689                                                  else
5690                                                    {
5691                                                      /* 33222222222211111111110000000000
5692                                                         10987654321098765432109876543210
5693                                                         xx100001011xxxxx100xxxxxxxxx1xxx
5694                                                         stnt1b.  */
5695                                                      return 2797;
5696                                                    }
5697                                                }
5698                                              else
5699                                                {
5700                                                  if (((word >> 15) & 0x1) == 0)
5701                                                    {
5702                                                      /* 33222222222211111111110000000000
5703                                                         10987654321098765432109876543210
5704                                                         xx100001011xxxxx010xxxxxxxxx1xxx
5705                                                         stnt1w.  */
5706                                                      return 2820;
5707                                                    }
5708                                                  else
5709                                                    {
5710                                                      /* 33222222222211111111110000000000
5711                                                         10987654321098765432109876543210
5712                                                         xx100001011xxxxx110xxxxxxxxx1xxx
5713                                                         stnt1w.  */
5714                                                      return 2821;
5715                                                    }
5716                                                }
5717                                            }
5718                                          else
5719                                            {
5720                                              if (((word >> 14) & 0x1) == 0)
5721                                                {
5722                                                  if (((word >> 15) & 0x1) == 0)
5723                                                    {
5724                                                      /* 33222222222211111111110000000000
5725                                                         10987654321098765432109876543210
5726                                                         xx100001011xxxxx001xxxxxxxxx1xxx
5727                                                         stnt1h.  */
5728                                                      return 2812;
5729                                                    }
5730                                                  else
5731                                                    {
5732                                                      /* 33222222222211111111110000000000
5733                                                         10987654321098765432109876543210
5734                                                         xx100001011xxxxx101xxxxxxxxx1xxx
5735                                                         stnt1h.  */
5736                                                      return 2813;
5737                                                    }
5738                                                }
5739                                              else
5740                                                {
5741                                                  if (((word >> 15) & 0x1) == 0)
5742                                                    {
5743                                                      /* 33222222222211111111110000000000
5744                                                         10987654321098765432109876543210
5745                                                         xx100001011xxxxx011xxxxxxxxx1xxx
5746                                                         stnt1d.  */
5747                                                      return 2804;
5748                                                    }
5749                                                  else
5750                                                    {
5751                                                      /* 33222222222211111111110000000000
5752                                                         10987654321098765432109876543210
5753                                                         xx100001011xxxxx111xxxxxxxxx1xxx
5754                                                         stnt1d.  */
5755                                                      return 2805;
5756                                                    }
5757                                                }
5758                                            }
5759                                        }
5760                                    }
5761                                  else
5762                                    {
5763                                      if (((word >> 4) & 0x1) == 0)
5764                                        {
5765                                          if (((word >> 30) & 0x1) == 0)
5766                                            {
5767                                              /* 33222222222211111111110000000000
5768                                                 10987654321098765432109876543210
5769                                                 x0100001111xxxxxxxxxxxxxxxx0xxxx
5770                                                 umopa.  */
5771                                              return 2418;
5772                                            }
5773                                          else
5774                                            {
5775                                              /* 33222222222211111111110000000000
5776                                                 10987654321098765432109876543210
5777                                                 x1100001111xxxxxxxxxxxxxxxx0xxxx
5778                                                 st1q.  */
5779                                              return 2444;
5780                                            }
5781                                        }
5782                                      else
5783                                        {
5784                                          /* 33222222222211111111110000000000
5785                                             10987654321098765432109876543210
5786                                             xx100001111xxxxxxxxxxxxxxxx1xxxx
5787                                             umops.  */
5788                                          return 2420;
5789                                        }
5790                                    }
5791                                }
5792                            }
5793                        }
5794                    }
5795                  else
5796                    {
5797                      if (((word >> 29) & 0x1) == 0)
5798                        {
5799                          if (((word >> 30) & 0x1) == 0)
5800                            {
5801                              /* 33222222222211111111110000000000
5802                                 10987654321098765432109876543210
5803                                 x0010001xxxxxxxxxxxxxxxxxxxxxxxx
5804                                 add.  */
5805                              return 12;
5806                            }
5807                          else
5808                            {
5809                              /* 33222222222211111111110000000000
5810                                 10987654321098765432109876543210
5811                                 x1010001xxxxxxxxxxxxxxxxxxxxxxxx
5812                                 sub.  */
5813                              return 16;
5814                            }
5815                        }
5816                      else
5817                        {
5818                          if (((word >> 30) & 0x1) == 0)
5819                            {
5820                              /* 33222222222211111111110000000000
5821                                 10987654321098765432109876543210
5822                                 x0110001xxxxxxxxxxxxxxxxxxxxxxxx
5823                                 adds.  */
5824                              return 14;
5825                            }
5826                          else
5827                            {
5828                              /* 33222222222211111111110000000000
5829                                 10987654321098765432109876543210
5830                                 x1110001xxxxxxxxxxxxxxxxxxxxxxxx
5831                                 subs.  */
5832                              return 17;
5833                            }
5834                        }
5835                    }
5836                }
5837            }
5838          else
5839            {
5840              if (((word >> 28) & 0x1) == 0)
5841                {
5842                  if (((word >> 22) & 0x1) == 0)
5843                    {
5844                      if (((word >> 23) & 0x1) == 0)
5845                        {
5846                          if (((word >> 29) & 0x1) == 0)
5847                            {
5848                              if (((word >> 15) & 0x1) == 0)
5849                                {
5850                                  if (((word >> 21) & 0x1) == 0)
5851                                    {
5852                                      if (((word >> 31) & 0x1) == 0)
5853                                        {
5854                                          if (((word >> 30) & 0x1) == 0)
5855                                            {
5856                                              /* 33222222222211111111110000000000
5857                                                 10987654321098765432109876543210
5858                                                 0000100x000xxxxx0xxxxxxxxxxxxxxx
5859                                                 stxrb.  */
5860                                              return 937;
5861                                            }
5862                                          else
5863                                            {
5864                                              /* 33222222222211111111110000000000
5865                                                 10987654321098765432109876543210
5866                                                 0100100x000xxxxx0xxxxxxxxxxxxxxx
5867                                                 stxrh.  */
5868                                              return 943;
5869                                            }
5870                                        }
5871                                      else
5872                                        {
5873                                          /* 33222222222211111111110000000000
5874                                             10987654321098765432109876543210
5875                                             1x00100x000xxxxx0xxxxxxxxxxxxxxx
5876                                             stxr.  */
5877                                          return 949;
5878                                        }
5879                                    }
5880                                  else
5881                                    {
5882                                      if (((word >> 31) & 0x1) == 0)
5883                                        {
5884                                          /* 33222222222211111111110000000000
5885                                             10987654321098765432109876543210
5886                                             0x00100x001xxxxx0xxxxxxxxxxxxxxx
5887                                             casp.  */
5888                                          return 1026;
5889                                        }
5890                                      else
5891                                        {
5892                                          /* 33222222222211111111110000000000
5893                                             10987654321098765432109876543210
5894                                             1x00100x001xxxxx0xxxxxxxxxxxxxxx
5895                                             stxp.  */
5896                                          return 951;
5897                                        }
5898                                    }
5899                                }
5900                              else
5901                                {
5902                                  if (((word >> 21) & 0x1) == 0)
5903                                    {
5904                                      if (((word >> 31) & 0x1) == 0)
5905                                        {
5906                                          if (((word >> 30) & 0x1) == 0)
5907                                            {
5908                                              /* 33222222222211111111110000000000
5909                                                 10987654321098765432109876543210
5910                                                 0000100x000xxxxx1xxxxxxxxxxxxxxx
5911                                                 stlxrb.  */
5912                                              return 938;
5913                                            }
5914                                          else
5915                                            {
5916                                              /* 33222222222211111111110000000000
5917                                                 10987654321098765432109876543210
5918                                                 0100100x000xxxxx1xxxxxxxxxxxxxxx
5919                                                 stlxrh.  */
5920                                              return 944;
5921                                            }
5922                                        }
5923                                      else
5924                                        {
5925                                          /* 33222222222211111111110000000000
5926                                             10987654321098765432109876543210
5927                                             1x00100x000xxxxx1xxxxxxxxxxxxxxx
5928                                             stlxr.  */
5929                                          return 950;
5930                                        }
5931                                    }
5932                                  else
5933                                    {
5934                                      if (((word >> 31) & 0x1) == 0)
5935                                        {
5936                                          /* 33222222222211111111110000000000
5937                                             10987654321098765432109876543210
5938                                             0x00100x001xxxxx1xxxxxxxxxxxxxxx
5939                                             caspl.  */
5940                                          return 1028;
5941                                        }
5942                                      else
5943                                        {
5944                                          /* 33222222222211111111110000000000
5945                                             10987654321098765432109876543210
5946                                             1x00100x001xxxxx1xxxxxxxxxxxxxxx
5947                                             stlxp.  */
5948                                          return 952;
5949                                        }
5950                                    }
5951                                }
5952                            }
5953                          else
5954                            {
5955                              if (((word >> 30) & 0x1) == 0)
5956                                {
5957                                  /* 33222222222211111111110000000000
5958                                     10987654321098765432109876543210
5959                                     x010100x00xxxxxxxxxxxxxxxxxxxxxx
5960                                     stnp.  */
5961                                  return 971;
5962                                }
5963                              else
5964                                {
5965                                  /* 33222222222211111111110000000000
5966                                     10987654321098765432109876543210
5967                                     x110100x00xxxxxxxxxxxxxxxxxxxxxx
5968                                     stgp.  */
5969                                  return 980;
5970                                }
5971                            }
5972                        }
5973                      else
5974                        {
5975                          if (((word >> 29) & 0x1) == 0)
5976                            {
5977                              if (((word >> 15) & 0x1) == 0)
5978                                {
5979                                  if (((word >> 21) & 0x1) == 0)
5980                                    {
5981                                      if (((word >> 31) & 0x1) == 0)
5982                                        {
5983                                          /* 33222222222211111111110000000000
5984                                             10987654321098765432109876543210
5985                                             0x00100x100xxxxx0xxxxxxxxxxxxxxx
5986                                             stllrb.  */
5987                                          return 969;
5988                                        }
5989                                      else
5990                                        {
5991                                          /* 33222222222211111111110000000000
5992                                             10987654321098765432109876543210
5993                                             1x00100x100xxxxx0xxxxxxxxxxxxxxx
5994                                             stllr.  */
5995                                          return 968;
5996                                        }
5997                                    }
5998                                  else
5999                                    {
6000                                      if (((word >> 31) & 0x1) == 0)
6001                                        {
6002                                          if (((word >> 30) & 0x1) == 0)
6003                                            {
6004                                              /* 33222222222211111111110000000000
6005                                                 10987654321098765432109876543210
6006                                                 0000100x101xxxxx0xxxxxxxxxxxxxxx
6007                                                 casb.  */
6008                                              return 1014;
6009                                            }
6010                                          else
6011                                            {
6012                                              /* 33222222222211111111110000000000
6013                                                 10987654321098765432109876543210
6014                                                 0100100x101xxxxx0xxxxxxxxxxxxxxx
6015                                                 cash.  */
6016                                              return 1015;
6017                                            }
6018                                        }
6019                                      else
6020                                        {
6021                                          /* 33222222222211111111110000000000
6022                                             10987654321098765432109876543210
6023                                             1x00100x101xxxxx0xxxxxxxxxxxxxxx
6024                                             cas.  */
6025                                          return 1016;
6026                                        }
6027                                    }
6028                                }
6029                              else
6030                                {
6031                                  if (((word >> 21) & 0x1) == 0)
6032                                    {
6033                                      if (((word >> 31) & 0x1) == 0)
6034                                        {
6035                                          if (((word >> 30) & 0x1) == 0)
6036                                            {
6037                                              /* 33222222222211111111110000000000
6038                                                 10987654321098765432109876543210
6039                                                 0000100x100xxxxx1xxxxxxxxxxxxxxx
6040                                                 stlrb.  */
6041                                              return 941;
6042                                            }
6043                                          else
6044                                            {
6045                                              /* 33222222222211111111110000000000
6046                                                 10987654321098765432109876543210
6047                                                 0100100x100xxxxx1xxxxxxxxxxxxxxx
6048                                                 stlrh.  */
6049                                              return 947;
6050                                            }
6051                                        }
6052                                      else
6053                                        {
6054                                          /* 33222222222211111111110000000000
6055                                             10987654321098765432109876543210
6056                                             1x00100x100xxxxx1xxxxxxxxxxxxxxx
6057                                             stlr.  */
6058                                          return 957;
6059                                        }
6060                                    }
6061                                  else
6062                                    {
6063                                      if (((word >> 31) & 0x1) == 0)
6064                                        {
6065                                          if (((word >> 30) & 0x1) == 0)
6066                                            {
6067                                              /* 33222222222211111111110000000000
6068                                                 10987654321098765432109876543210
6069                                                 0000100x101xxxxx1xxxxxxxxxxxxxxx
6070                                                 caslb.  */
6071                                              return 1018;
6072                                            }
6073                                          else
6074                                            {
6075                                              /* 33222222222211111111110000000000
6076                                                 10987654321098765432109876543210
6077                                                 0100100x101xxxxx1xxxxxxxxxxxxxxx
6078                                                 caslh.  */
6079                                              return 1021;
6080                                            }
6081                                        }
6082                                      else
6083                                        {
6084                                          /* 33222222222211111111110000000000
6085                                             10987654321098765432109876543210
6086                                             1x00100x101xxxxx1xxxxxxxxxxxxxxx
6087                                             casl.  */
6088                                          return 1024;
6089                                        }
6090                                    }
6091                                }
6092                            }
6093                          else
6094                            {
6095                              if (((word >> 30) & 0x1) == 0)
6096                                {
6097                                  /* 33222222222211111111110000000000
6098                                     10987654321098765432109876543210
6099                                     x010100x10xxxxxxxxxxxxxxxxxxxxxx
6100                                     stp.  */
6101                                  return 981;
6102                                }
6103                              else
6104                                {
6105                                  /* 33222222222211111111110000000000
6106                                     10987654321098765432109876543210
6107                                     x110100x10xxxxxxxxxxxxxxxxxxxxxx
6108                                     stgp.  */
6109                                  return 986;
6110                                }
6111                            }
6112                        }
6113                    }
6114                  else
6115                    {
6116                      if (((word >> 23) & 0x1) == 0)
6117                        {
6118                          if (((word >> 29) & 0x1) == 0)
6119                            {
6120                              if (((word >> 15) & 0x1) == 0)
6121                                {
6122                                  if (((word >> 21) & 0x1) == 0)
6123                                    {
6124                                      if (((word >> 31) & 0x1) == 0)
6125                                        {
6126                                          if (((word >> 30) & 0x1) == 0)
6127                                            {
6128                                              /* 33222222222211111111110000000000
6129                                                 10987654321098765432109876543210
6130                                                 0000100x010xxxxx0xxxxxxxxxxxxxxx
6131                                                 ldxrb.  */
6132                                              return 939;
6133                                            }
6134                                          else
6135                                            {
6136                                              /* 33222222222211111111110000000000
6137                                                 10987654321098765432109876543210
6138                                                 0100100x010xxxxx0xxxxxxxxxxxxxxx
6139                                                 ldxrh.  */
6140                                              return 945;
6141                                            }
6142                                        }
6143                                      else
6144                                        {
6145                                          /* 33222222222211111111110000000000
6146                                             10987654321098765432109876543210
6147                                             1x00100x010xxxxx0xxxxxxxxxxxxxxx
6148                                             ldxr.  */
6149                                          return 953;
6150                                        }
6151                                    }
6152                                  else
6153                                    {
6154                                      if (((word >> 31) & 0x1) == 0)
6155                                        {
6156                                          /* 33222222222211111111110000000000
6157                                             10987654321098765432109876543210
6158                                             0x00100x011xxxxx0xxxxxxxxxxxxxxx
6159                                             caspa.  */
6160                                          return 1027;
6161                                        }
6162                                      else
6163                                        {
6164                                          /* 33222222222211111111110000000000
6165                                             10987654321098765432109876543210
6166                                             1x00100x011xxxxx0xxxxxxxxxxxxxxx
6167                                             ldxp.  */
6168                                          return 955;
6169                                        }
6170                                    }
6171                                }
6172                              else
6173                                {
6174                                  if (((word >> 21) & 0x1) == 0)
6175                                    {
6176                                      if (((word >> 31) & 0x1) == 0)
6177                                        {
6178                                          if (((word >> 30) & 0x1) == 0)
6179                                            {
6180                                              /* 33222222222211111111110000000000
6181                                                 10987654321098765432109876543210
6182                                                 0000100x010xxxxx1xxxxxxxxxxxxxxx
6183                                                 ldaxrb.  */
6184                                              return 940;
6185                                            }
6186                                          else
6187                                            {
6188                                              /* 33222222222211111111110000000000
6189                                                 10987654321098765432109876543210
6190                                                 0100100x010xxxxx1xxxxxxxxxxxxxxx
6191                                                 ldaxrh.  */
6192                                              return 946;
6193                                            }
6194                                        }
6195                                      else
6196                                        {
6197                                          /* 33222222222211111111110000000000
6198                                             10987654321098765432109876543210
6199                                             1x00100x010xxxxx1xxxxxxxxxxxxxxx
6200                                             ldaxr.  */
6201                                          return 954;
6202                                        }
6203                                    }
6204                                  else
6205                                    {
6206                                      if (((word >> 31) & 0x1) == 0)
6207                                        {
6208                                          /* 33222222222211111111110000000000
6209                                             10987654321098765432109876543210
6210                                             0x00100x011xxxxx1xxxxxxxxxxxxxxx
6211                                             caspal.  */
6212                                          return 1029;
6213                                        }
6214                                      else
6215                                        {
6216                                          /* 33222222222211111111110000000000
6217                                             10987654321098765432109876543210
6218                                             1x00100x011xxxxx1xxxxxxxxxxxxxxx
6219                                             ldaxp.  */
6220                                          return 956;
6221                                        }
6222                                    }
6223                                }
6224                            }
6225                          else
6226                            {
6227                              if (((word >> 30) & 0x1) == 0)
6228                                {
6229                                  /* 33222222222211111111110000000000
6230                                     10987654321098765432109876543210
6231                                     x010100x01xxxxxxxxxxxxxxxxxxxxxx
6232                                     ldnp.  */
6233                                  return 972;
6234                                }
6235                              else
6236                                {
6237                                  /* 33222222222211111111110000000000
6238                                     10987654321098765432109876543210
6239                                     x110100x01xxxxxxxxxxxxxxxxxxxxxx
6240                                     ldpsw.  */
6241                                  return 979;
6242                                }
6243                            }
6244                        }
6245                      else
6246                        {
6247                          if (((word >> 29) & 0x1) == 0)
6248                            {
6249                              if (((word >> 15) & 0x1) == 0)
6250                                {
6251                                  if (((word >> 21) & 0x1) == 0)
6252                                    {
6253                                      if (((word >> 31) & 0x1) == 0)
6254                                        {
6255                                          if (((word >> 30) & 0x1) == 0)
6256                                            {
6257                                              /* 33222222222211111111110000000000
6258                                                 10987654321098765432109876543210
6259                                                 0000100x110xxxxx0xxxxxxxxxxxxxxx
6260                                                 ldlarb.  */
6261                                              return 966;
6262                                            }
6263                                          else
6264                                            {
6265                                              /* 33222222222211111111110000000000
6266                                                 10987654321098765432109876543210
6267                                                 0100100x110xxxxx0xxxxxxxxxxxxxxx
6268                                                 ldlarh.  */
6269                                              return 967;
6270                                            }
6271                                        }
6272                                      else
6273                                        {
6274                                          /* 33222222222211111111110000000000
6275                                             10987654321098765432109876543210
6276                                             1x00100x110xxxxx0xxxxxxxxxxxxxxx
6277                                             ldlar.  */
6278                                          return 965;
6279                                        }
6280                                    }
6281                                  else
6282                                    {
6283                                      if (((word >> 31) & 0x1) == 0)
6284                                        {
6285                                          if (((word >> 30) & 0x1) == 0)
6286                                            {
6287                                              /* 33222222222211111111110000000000
6288                                                 10987654321098765432109876543210
6289                                                 0000100x111xxxxx0xxxxxxxxxxxxxxx
6290                                                 casab.  */
6291                                              return 1017;
6292                                            }
6293                                          else
6294                                            {
6295                                              /* 33222222222211111111110000000000
6296                                                 10987654321098765432109876543210
6297                                                 0100100x111xxxxx0xxxxxxxxxxxxxxx
6298                                                 casah.  */
6299                                              return 1020;
6300                                            }
6301                                        }
6302                                      else
6303                                        {
6304                                          /* 33222222222211111111110000000000
6305                                             10987654321098765432109876543210
6306                                             1x00100x111xxxxx0xxxxxxxxxxxxxxx
6307                                             casa.  */
6308                                          return 1023;
6309                                        }
6310                                    }
6311                                }
6312                              else
6313                                {
6314                                  if (((word >> 21) & 0x1) == 0)
6315                                    {
6316                                      if (((word >> 31) & 0x1) == 0)
6317                                        {
6318                                          if (((word >> 30) & 0x1) == 0)
6319                                            {
6320                                              /* 33222222222211111111110000000000
6321                                                 10987654321098765432109876543210
6322                                                 0000100x110xxxxx1xxxxxxxxxxxxxxx
6323                                                 ldarb.  */
6324                                              return 942;
6325                                            }
6326                                          else
6327                                            {
6328                                              /* 33222222222211111111110000000000
6329                                                 10987654321098765432109876543210
6330                                                 0100100x110xxxxx1xxxxxxxxxxxxxxx
6331                                                 ldarh.  */
6332                                              return 948;
6333                                            }
6334                                        }
6335                                      else
6336                                        {
6337                                          /* 33222222222211111111110000000000
6338                                             10987654321098765432109876543210
6339                                             1x00100x110xxxxx1xxxxxxxxxxxxxxx
6340                                             ldar.  */
6341                                          return 958;
6342                                        }
6343                                    }
6344                                  else
6345                                    {
6346                                      if (((word >> 31) & 0x1) == 0)
6347                                        {
6348                                          if (((word >> 30) & 0x1) == 0)
6349                                            {
6350                                              /* 33222222222211111111110000000000
6351                                                 10987654321098765432109876543210
6352                                                 0000100x111xxxxx1xxxxxxxxxxxxxxx
6353                                                 casalb.  */
6354                                              return 1019;
6355                                            }
6356                                          else
6357                                            {
6358                                              /* 33222222222211111111110000000000
6359                                                 10987654321098765432109876543210
6360                                                 0100100x111xxxxx1xxxxxxxxxxxxxxx
6361                                                 casalh.  */
6362                                              return 1022;
6363                                            }
6364                                        }
6365                                      else
6366                                        {
6367                                          /* 33222222222211111111110000000000
6368                                             10987654321098765432109876543210
6369                                             1x00100x111xxxxx1xxxxxxxxxxxxxxx
6370                                             casal.  */
6371                                          return 1025;
6372                                        }
6373                                    }
6374                                }
6375                            }
6376                          else
6377                            {
6378                              if (((word >> 30) & 0x1) == 0)
6379                                {
6380                                  /* 33222222222211111111110000000000
6381                                     10987654321098765432109876543210
6382                                     x010100x11xxxxxxxxxxxxxxxxxxxxxx
6383                                     ldp.  */
6384                                  return 982;
6385                                }
6386                              else
6387                                {
6388                                  /* 33222222222211111111110000000000
6389                                     10987654321098765432109876543210
6390                                     x110100x11xxxxxxxxxxxxxxxxxxxxxx
6391                                     ldpsw.  */
6392                                  return 985;
6393                                }
6394                            }
6395                        }
6396                    }
6397                }
6398              else
6399                {
6400                  if (((word >> 24) & 0x1) == 0)
6401                    {
6402                      if (((word >> 29) & 0x1) == 0)
6403                        {
6404                          if (((word >> 31) & 0x1) == 0)
6405                            {
6406                              /* 33222222222211111111110000000000
6407                                 10987654321098765432109876543210
6408                                 0x011000xxxxxxxxxxxxxxxxxxxxxxxx
6409                                 ldr.  */
6410                              return 987;
6411                            }
6412                          else
6413                            {
6414                              if (((word >> 30) & 0x1) == 0)
6415                                {
6416                                  /* 33222222222211111111110000000000
6417                                     10987654321098765432109876543210
6418                                     10011000xxxxxxxxxxxxxxxxxxxxxxxx
6419                                     ldrsw.  */
6420                                  return 989;
6421                                }
6422                              else
6423                                {
6424                                  /* 33222222222211111111110000000000
6425                                     10987654321098765432109876543210
6426                                     11011000xxxxxxxxxxxxxxxxxxxxxxxx
6427                                     prfm.  */
6428                                  return 990;
6429                                }
6430                            }
6431                        }
6432                      else
6433                        {
6434                          if (((word >> 10) & 0x1) == 0)
6435                            {
6436                              if (((word >> 11) & 0x1) == 0)
6437                                {
6438                                  if (((word >> 21) & 0x1) == 0)
6439                                    {
6440                                      if (((word >> 23) & 0x1) == 0)
6441                                        {
6442                                          if (((word >> 22) & 0x1) == 0)
6443                                            {
6444                                              if (((word >> 31) & 0x1) == 0)
6445                                                {
6446                                                  if (((word >> 30) & 0x1) == 0)
6447                                                    {
6448                                                      /* 33222222222211111111110000000000
6449                                                         10987654321098765432109876543210
6450                                                         00111000000xxxxxxxxx00xxxxxxxxxx
6451                                                         sturb.  */
6452                                                      return 922;
6453                                                    }
6454                                                  else
6455                                                    {
6456                                                      /* 33222222222211111111110000000000
6457                                                         10987654321098765432109876543210
6458                                                         01111000000xxxxxxxxx00xxxxxxxxxx
6459                                                         sturh.  */
6460                                                      return 927;
6461                                                    }
6462                                                }
6463                                              else
6464                                                {
6465                                                  /* 33222222222211111111110000000000
6466                                                     10987654321098765432109876543210
6467                                                     1x111000000xxxxxxxxx00xxxxxxxxxx
6468                                                     stur.  */
6469                                                  return 930;
6470                                                }
6471                                            }
6472                                          else
6473                                            {
6474                                              if (((word >> 31) & 0x1) == 0)
6475                                                {
6476                                                  if (((word >> 30) & 0x1) == 0)
6477                                                    {
6478                                                      /* 33222222222211111111110000000000
6479                                                         10987654321098765432109876543210
6480                                                         00111000010xxxxxxxxx00xxxxxxxxxx
6481                                                         ldurb.  */
6482                                                      return 923;
6483                                                    }
6484                                                  else
6485                                                    {
6486                                                      /* 33222222222211111111110000000000
6487                                                         10987654321098765432109876543210
6488                                                         01111000010xxxxxxxxx00xxxxxxxxxx
6489                                                         ldurh.  */
6490                                                      return 928;
6491                                                    }
6492                                                }
6493                                              else
6494                                                {
6495                                                  /* 33222222222211111111110000000000
6496                                                     10987654321098765432109876543210
6497                                                     1x111000010xxxxxxxxx00xxxxxxxxxx
6498                                                     ldur.  */
6499                                                  return 931;
6500                                                }
6501                                            }
6502                                        }
6503                                      else
6504                                        {
6505                                          if (((word >> 30) & 0x1) == 0)
6506                                            {
6507                                              if (((word >> 31) & 0x1) == 0)
6508                                                {
6509                                                  /* 33222222222211111111110000000000
6510                                                     10987654321098765432109876543210
6511                                                     001110001x0xxxxxxxxx00xxxxxxxxxx
6512                                                     ldursb.  */
6513                                                  return 924;
6514                                                }
6515                                              else
6516                                                {
6517                                                  /* 33222222222211111111110000000000
6518                                                     10987654321098765432109876543210
6519                                                     101110001x0xxxxxxxxx00xxxxxxxxxx
6520                                                     ldursw.  */
6521                                                  return 932;
6522                                                }
6523                                            }
6524                                          else
6525                                            {
6526                                              if (((word >> 31) & 0x1) == 0)
6527                                                {
6528                                                  /* 33222222222211111111110000000000
6529                                                     10987654321098765432109876543210
6530                                                     011110001x0xxxxxxxxx00xxxxxxxxxx
6531                                                     ldursh.  */
6532                                                  return 929;
6533                                                }
6534                                              else
6535                                                {
6536                                                  /* 33222222222211111111110000000000
6537                                                     10987654321098765432109876543210
6538                                                     111110001x0xxxxxxxxx00xxxxxxxxxx
6539                                                     prfum.  */
6540                                                  return 933;
6541                                                }
6542                                            }
6543                                        }
6544                                    }
6545                                  else
6546                                    {
6547                                      if (((word >> 12) & 0x1) == 0)
6548                                        {
6549                                          if (((word >> 13) & 0x1) == 0)
6550                                            {
6551                                              if (((word >> 14) & 0x1) == 0)
6552                                                {
6553                                                  if (((word >> 15) & 0x1) == 0)
6554                                                    {
6555                                                      if (((word >> 22) & 0x1) == 0)
6556                                                        {
6557                                                          if (((word >> 23) & 0x1) == 0)
6558                                                            {
6559                                                              if (((word >> 31) & 0x1) == 0)
6560                                                                {
6561                                                                  if (((word >> 30) & 0x1) == 0)
6562                                                                    {
6563                                                                      /* 33222222222211111111110000000000
6564                                                                         10987654321098765432109876543210
6565                                                                         00111000001xxxxx000000xxxxxxxxxx
6566                                                                         ldaddb.  */
6567                                                                      return 1042;
6568                                                                    }
6569                                                                  else
6570                                                                    {
6571                                                                      /* 33222222222211111111110000000000
6572                                                                         10987654321098765432109876543210
6573                                                                         01111000001xxxxx000000xxxxxxxxxx
6574                                                                         ldaddh.  */
6575                                                                      return 1043;
6576                                                                    }
6577                                                                }
6578                                                              else
6579                                                                {
6580                                                                  /* 33222222222211111111110000000000
6581                                                                     10987654321098765432109876543210
6582                                                                     1x111000001xxxxx000000xxxxxxxxxx
6583                                                                     ldadd.  */
6584                                                                  return 1044;
6585                                                                }
6586                                                            }
6587                                                          else
6588                                                            {
6589                                                              if (((word >> 31) & 0x1) == 0)
6590                                                                {
6591                                                                  if (((word >> 30) & 0x1) == 0)
6592                                                                    {
6593                                                                      /* 33222222222211111111110000000000
6594                                                                         10987654321098765432109876543210
6595                                                                         00111000101xxxxx000000xxxxxxxxxx
6596                                                                         ldaddab.  */
6597                                                                      return 1045;
6598                                                                    }
6599                                                                  else
6600                                                                    {
6601                                                                      /* 33222222222211111111110000000000
6602                                                                         10987654321098765432109876543210
6603                                                                         01111000101xxxxx000000xxxxxxxxxx
6604                                                                         ldaddah.  */
6605                                                                      return 1048;
6606                                                                    }
6607                                                                }
6608                                                              else
6609                                                                {
6610                                                                  /* 33222222222211111111110000000000
6611                                                                     10987654321098765432109876543210
6612                                                                     1x111000101xxxxx000000xxxxxxxxxx
6613                                                                     ldadda.  */
6614                                                                  return 1051;
6615                                                                }
6616                                                            }
6617                                                        }
6618                                                      else
6619                                                        {
6620                                                          if (((word >> 23) & 0x1) == 0)
6621                                                            {
6622                                                              if (((word >> 31) & 0x1) == 0)
6623                                                                {
6624                                                                  if (((word >> 30) & 0x1) == 0)
6625                                                                    {
6626                                                                      /* 33222222222211111111110000000000
6627                                                                         10987654321098765432109876543210
6628                                                                         00111000011xxxxx000000xxxxxxxxxx
6629                                                                         ldaddlb.  */
6630                                                                      return 1046;
6631                                                                    }
6632                                                                  else
6633                                                                    {
6634                                                                      /* 33222222222211111111110000000000
6635                                                                         10987654321098765432109876543210
6636                                                                         01111000011xxxxx000000xxxxxxxxxx
6637                                                                         ldaddlh.  */
6638                                                                      return 1049;
6639                                                                    }
6640                                                                }
6641                                                              else
6642                                                                {
6643                                                                  /* 33222222222211111111110000000000
6644                                                                     10987654321098765432109876543210
6645                                                                     1x111000011xxxxx000000xxxxxxxxxx
6646                                                                     ldaddl.  */
6647                                                                  return 1052;
6648                                                                }
6649                                                            }
6650                                                          else
6651                                                            {
6652                                                              if (((word >> 31) & 0x1) == 0)
6653                                                                {
6654                                                                  if (((word >> 30) & 0x1) == 0)
6655                                                                    {
6656                                                                      /* 33222222222211111111110000000000
6657                                                                         10987654321098765432109876543210
6658                                                                         00111000111xxxxx000000xxxxxxxxxx
6659                                                                         ldaddalb.  */
6660                                                                      return 1047;
6661                                                                    }
6662                                                                  else
6663                                                                    {
6664                                                                      /* 33222222222211111111110000000000
6665                                                                         10987654321098765432109876543210
6666                                                                         01111000111xxxxx000000xxxxxxxxxx
6667                                                                         ldaddalh.  */
6668                                                                      return 1050;
6669                                                                    }
6670                                                                }
6671                                                              else
6672                                                                {
6673                                                                  /* 33222222222211111111110000000000
6674                                                                     10987654321098765432109876543210
6675                                                                     1x111000111xxxxx000000xxxxxxxxxx
6676                                                                     ldaddal.  */
6677                                                                  return 1053;
6678                                                                }
6679                                                            }
6680                                                        }
6681                                                    }
6682                                                  else
6683                                                    {
6684                                                      if (((word >> 22) & 0x1) == 0)
6685                                                        {
6686                                                          if (((word >> 23) & 0x1) == 0)
6687                                                            {
6688                                                              if (((word >> 31) & 0x1) == 0)
6689                                                                {
6690                                                                  if (((word >> 30) & 0x1) == 0)
6691                                                                    {
6692                                                                      /* 33222222222211111111110000000000
6693                                                                         10987654321098765432109876543210
6694                                                                         00111000001xxxxx100000xxxxxxxxxx
6695                                                                         swpb.  */
6696                                                                      return 1030;
6697                                                                    }
6698                                                                  else
6699                                                                    {
6700                                                                      /* 33222222222211111111110000000000
6701                                                                         10987654321098765432109876543210
6702                                                                         01111000001xxxxx100000xxxxxxxxxx
6703                                                                         swph.  */
6704                                                                      return 1031;
6705                                                                    }
6706                                                                }
6707                                                              else
6708                                                                {
6709                                                                  /* 33222222222211111111110000000000
6710                                                                     10987654321098765432109876543210
6711                                                                     1x111000001xxxxx100000xxxxxxxxxx
6712                                                                     swp.  */
6713                                                                  return 1032;
6714                                                                }
6715                                                            }
6716                                                          else
6717                                                            {
6718                                                              if (((word >> 31) & 0x1) == 0)
6719                                                                {
6720                                                                  if (((word >> 30) & 0x1) == 0)
6721                                                                    {
6722                                                                      /* 33222222222211111111110000000000
6723                                                                         10987654321098765432109876543210
6724                                                                         00111000101xxxxx100000xxxxxxxxxx
6725                                                                         swpab.  */
6726                                                                      return 1033;
6727                                                                    }
6728                                                                  else
6729                                                                    {
6730                                                                      /* 33222222222211111111110000000000
6731                                                                         10987654321098765432109876543210
6732                                                                         01111000101xxxxx100000xxxxxxxxxx
6733                                                                         swpah.  */
6734                                                                      return 1036;
6735                                                                    }
6736                                                                }
6737                                                              else
6738                                                                {
6739                                                                  /* 33222222222211111111110000000000
6740                                                                     10987654321098765432109876543210
6741                                                                     1x111000101xxxxx100000xxxxxxxxxx
6742                                                                     swpa.  */
6743                                                                  return 1039;
6744                                                                }
6745                                                            }
6746                                                        }
6747                                                      else
6748                                                        {
6749                                                          if (((word >> 23) & 0x1) == 0)
6750                                                            {
6751                                                              if (((word >> 31) & 0x1) == 0)
6752                                                                {
6753                                                                  if (((word >> 30) & 0x1) == 0)
6754                                                                    {
6755                                                                      /* 33222222222211111111110000000000
6756                                                                         10987654321098765432109876543210
6757                                                                         00111000011xxxxx100000xxxxxxxxxx
6758                                                                         swplb.  */
6759                                                                      return 1034;
6760                                                                    }
6761                                                                  else
6762                                                                    {
6763                                                                      /* 33222222222211111111110000000000
6764                                                                         10987654321098765432109876543210
6765                                                                         01111000011xxxxx100000xxxxxxxxxx
6766                                                                         swplh.  */
6767                                                                      return 1037;
6768                                                                    }
6769                                                                }
6770                                                              else
6771                                                                {
6772                                                                  /* 33222222222211111111110000000000
6773                                                                     10987654321098765432109876543210
6774                                                                     1x111000011xxxxx100000xxxxxxxxxx
6775                                                                     swpl.  */
6776                                                                  return 1040;
6777                                                                }
6778                                                            }
6779                                                          else
6780                                                            {
6781                                                              if (((word >> 31) & 0x1) == 0)
6782                                                                {
6783                                                                  if (((word >> 30) & 0x1) == 0)
6784                                                                    {
6785                                                                      /* 33222222222211111111110000000000
6786                                                                         10987654321098765432109876543210
6787                                                                         00111000111xxxxx100000xxxxxxxxxx
6788                                                                         swpalb.  */
6789                                                                      return 1035;
6790                                                                    }
6791                                                                  else
6792                                                                    {
6793                                                                      /* 33222222222211111111110000000000
6794                                                                         10987654321098765432109876543210
6795                                                                         01111000111xxxxx100000xxxxxxxxxx
6796                                                                         swpalh.  */
6797                                                                      return 1038;
6798                                                                    }
6799                                                                }
6800                                                              else
6801                                                                {
6802                                                                  /* 33222222222211111111110000000000
6803                                                                     10987654321098765432109876543210
6804                                                                     1x111000111xxxxx100000xxxxxxxxxx
6805                                                                     swpal.  */
6806                                                                  return 1041;
6807                                                                }
6808                                                            }
6809                                                        }
6810                                                    }
6811                                                }
6812                                              else
6813                                                {
6814                                                  if (((word >> 15) & 0x1) == 0)
6815                                                    {
6816                                                      if (((word >> 22) & 0x1) == 0)
6817                                                        {
6818                                                          if (((word >> 23) & 0x1) == 0)
6819                                                            {
6820                                                              if (((word >> 31) & 0x1) == 0)
6821                                                                {
6822                                                                  if (((word >> 30) & 0x1) == 0)
6823                                                                    {
6824                                                                      /* 33222222222211111111110000000000
6825                                                                         10987654321098765432109876543210
6826                                                                         00111000001xxxxx010000xxxxxxxxxx
6827                                                                         ldsmaxb.  */
6828                                                                      return 1090;
6829                                                                    }
6830                                                                  else
6831                                                                    {
6832                                                                      /* 33222222222211111111110000000000
6833                                                                         10987654321098765432109876543210
6834                                                                         01111000001xxxxx010000xxxxxxxxxx
6835                                                                         ldsmaxh.  */
6836                                                                      return 1091;
6837                                                                    }
6838                                                                }
6839                                                              else
6840                                                                {
6841                                                                  /* 33222222222211111111110000000000
6842                                                                     10987654321098765432109876543210
6843                                                                     1x111000001xxxxx010000xxxxxxxxxx
6844                                                                     ldsmax.  */
6845                                                                  return 1092;
6846                                                                }
6847                                                            }
6848                                                          else
6849                                                            {
6850                                                              if (((word >> 31) & 0x1) == 0)
6851                                                                {
6852                                                                  if (((word >> 30) & 0x1) == 0)
6853                                                                    {
6854                                                                      /* 33222222222211111111110000000000
6855                                                                         10987654321098765432109876543210
6856                                                                         00111000101xxxxx010000xxxxxxxxxx
6857                                                                         ldsmaxab.  */
6858                                                                      return 1093;
6859                                                                    }
6860                                                                  else
6861                                                                    {
6862                                                                      /* 33222222222211111111110000000000
6863                                                                         10987654321098765432109876543210
6864                                                                         01111000101xxxxx010000xxxxxxxxxx
6865                                                                         ldsmaxah.  */
6866                                                                      return 1096;
6867                                                                    }
6868                                                                }
6869                                                              else
6870                                                                {
6871                                                                  /* 33222222222211111111110000000000
6872                                                                     10987654321098765432109876543210
6873                                                                     1x111000101xxxxx010000xxxxxxxxxx
6874                                                                     ldsmaxa.  */
6875                                                                  return 1099;
6876                                                                }
6877                                                            }
6878                                                        }
6879                                                      else
6880                                                        {
6881                                                          if (((word >> 23) & 0x1) == 0)
6882                                                            {
6883                                                              if (((word >> 31) & 0x1) == 0)
6884                                                                {
6885                                                                  if (((word >> 30) & 0x1) == 0)
6886                                                                    {
6887                                                                      /* 33222222222211111111110000000000
6888                                                                         10987654321098765432109876543210
6889                                                                         00111000011xxxxx010000xxxxxxxxxx
6890                                                                         ldsmaxlb.  */
6891                                                                      return 1094;
6892                                                                    }
6893                                                                  else
6894                                                                    {
6895                                                                      /* 33222222222211111111110000000000
6896                                                                         10987654321098765432109876543210
6897                                                                         01111000011xxxxx010000xxxxxxxxxx
6898                                                                         ldsmaxlh.  */
6899                                                                      return 1097;
6900                                                                    }
6901                                                                }
6902                                                              else
6903                                                                {
6904                                                                  /* 33222222222211111111110000000000
6905                                                                     10987654321098765432109876543210
6906                                                                     1x111000011xxxxx010000xxxxxxxxxx
6907                                                                     ldsmaxl.  */
6908                                                                  return 1100;
6909                                                                }
6910                                                            }
6911                                                          else
6912                                                            {
6913                                                              if (((word >> 31) & 0x1) == 0)
6914                                                                {
6915                                                                  if (((word >> 30) & 0x1) == 0)
6916                                                                    {
6917                                                                      /* 33222222222211111111110000000000
6918                                                                         10987654321098765432109876543210
6919                                                                         00111000111xxxxx010000xxxxxxxxxx
6920                                                                         ldsmaxalb.  */
6921                                                                      return 1095;
6922                                                                    }
6923                                                                  else
6924                                                                    {
6925                                                                      /* 33222222222211111111110000000000
6926                                                                         10987654321098765432109876543210
6927                                                                         01111000111xxxxx010000xxxxxxxxxx
6928                                                                         ldsmaxalh.  */
6929                                                                      return 1098;
6930                                                                    }
6931                                                                }
6932                                                              else
6933                                                                {
6934                                                                  /* 33222222222211111111110000000000
6935                                                                     10987654321098765432109876543210
6936                                                                     1x111000111xxxxx010000xxxxxxxxxx
6937                                                                     ldsmaxal.  */
6938                                                                  return 1101;
6939                                                                }
6940                                                            }
6941                                                        }
6942                                                    }
6943                                                  else
6944                                                    {
6945                                                      if (((word >> 31) & 0x1) == 0)
6946                                                        {
6947                                                          if (((word >> 30) & 0x1) == 0)
6948                                                            {
6949                                                              /* 33222222222211111111110000000000
6950                                                                 10987654321098765432109876543210
6951                                                                 00111000xx1xxxxx110000xxxxxxxxxx
6952                                                                 ldaprb.  */
6953                                                              return 959;
6954                                                            }
6955                                                          else
6956                                                            {
6957                                                              /* 33222222222211111111110000000000
6958                                                                 10987654321098765432109876543210
6959                                                                 01111000xx1xxxxx110000xxxxxxxxxx
6960                                                                 ldaprh.  */
6961                                                              return 960;
6962                                                            }
6963                                                        }
6964                                                      else
6965                                                        {
6966                                                          /* 33222222222211111111110000000000
6967                                                             10987654321098765432109876543210
6968                                                             1x111000xx1xxxxx110000xxxxxxxxxx
6969                                                             ldapr.  */
6970                                                          return 961;
6971                                                        }
6972                                                    }
6973                                                }
6974                                            }
6975                                          else
6976                                            {
6977                                              if (((word >> 14) & 0x1) == 0)
6978                                                {
6979                                                  if (((word >> 15) & 0x1) == 0)
6980                                                    {
6981                                                      if (((word >> 22) & 0x1) == 0)
6982                                                        {
6983                                                          if (((word >> 23) & 0x1) == 0)
6984                                                            {
6985                                                              if (((word >> 31) & 0x1) == 0)
6986                                                                {
6987                                                                  if (((word >> 30) & 0x1) == 0)
6988                                                                    {
6989                                                                      /* 33222222222211111111110000000000
6990                                                                         10987654321098765432109876543210
6991                                                                         00111000001xxxxx001000xxxxxxxxxx
6992                                                                         ldeorb.  */
6993                                                                      return 1066;
6994                                                                    }
6995                                                                  else
6996                                                                    {
6997                                                                      /* 33222222222211111111110000000000
6998                                                                         10987654321098765432109876543210
6999                                                                         01111000001xxxxx001000xxxxxxxxxx
7000                                                                         ldeorh.  */
7001                                                                      return 1067;
7002                                                                    }
7003                                                                }
7004                                                              else
7005                                                                {
7006                                                                  /* 33222222222211111111110000000000
7007                                                                     10987654321098765432109876543210
7008                                                                     1x111000001xxxxx001000xxxxxxxxxx
7009                                                                     ldeor.  */
7010                                                                  return 1068;
7011                                                                }
7012                                                            }
7013                                                          else
7014                                                            {
7015                                                              if (((word >> 31) & 0x1) == 0)
7016                                                                {
7017                                                                  if (((word >> 30) & 0x1) == 0)
7018                                                                    {
7019                                                                      /* 33222222222211111111110000000000
7020                                                                         10987654321098765432109876543210
7021                                                                         00111000101xxxxx001000xxxxxxxxxx
7022                                                                         ldeorab.  */
7023                                                                      return 1069;
7024                                                                    }
7025                                                                  else
7026                                                                    {
7027                                                                      /* 33222222222211111111110000000000
7028                                                                         10987654321098765432109876543210
7029                                                                         01111000101xxxxx001000xxxxxxxxxx
7030                                                                         ldeorah.  */
7031                                                                      return 1072;
7032                                                                    }
7033                                                                }
7034                                                              else
7035                                                                {
7036                                                                  /* 33222222222211111111110000000000
7037                                                                     10987654321098765432109876543210
7038                                                                     1x111000101xxxxx001000xxxxxxxxxx
7039                                                                     ldeora.  */
7040                                                                  return 1075;
7041                                                                }
7042                                                            }
7043                                                        }
7044                                                      else
7045                                                        {
7046                                                          if (((word >> 23) & 0x1) == 0)
7047                                                            {
7048                                                              if (((word >> 31) & 0x1) == 0)
7049                                                                {
7050                                                                  if (((word >> 30) & 0x1) == 0)
7051                                                                    {
7052                                                                      /* 33222222222211111111110000000000
7053                                                                         10987654321098765432109876543210
7054                                                                         00111000011xxxxx001000xxxxxxxxxx
7055                                                                         ldeorlb.  */
7056                                                                      return 1070;
7057                                                                    }
7058                                                                  else
7059                                                                    {
7060                                                                      /* 33222222222211111111110000000000
7061                                                                         10987654321098765432109876543210
7062                                                                         01111000011xxxxx001000xxxxxxxxxx
7063                                                                         ldeorlh.  */
7064                                                                      return 1073;
7065                                                                    }
7066                                                                }
7067                                                              else
7068                                                                {
7069                                                                  /* 33222222222211111111110000000000
7070                                                                     10987654321098765432109876543210
7071                                                                     1x111000011xxxxx001000xxxxxxxxxx
7072                                                                     ldeorl.  */
7073                                                                  return 1076;
7074                                                                }
7075                                                            }
7076                                                          else
7077                                                            {
7078                                                              if (((word >> 31) & 0x1) == 0)
7079                                                                {
7080                                                                  if (((word >> 30) & 0x1) == 0)
7081                                                                    {
7082                                                                      /* 33222222222211111111110000000000
7083                                                                         10987654321098765432109876543210
7084                                                                         00111000111xxxxx001000xxxxxxxxxx
7085                                                                         ldeoralb.  */
7086                                                                      return 1071;
7087                                                                    }
7088                                                                  else
7089                                                                    {
7090                                                                      /* 33222222222211111111110000000000
7091                                                                         10987654321098765432109876543210
7092                                                                         01111000111xxxxx001000xxxxxxxxxx
7093                                                                         ldeoralh.  */
7094                                                                      return 1074;
7095                                                                    }
7096                                                                }
7097                                                              else
7098                                                                {
7099                                                                  /* 33222222222211111111110000000000
7100                                                                     10987654321098765432109876543210
7101                                                                     1x111000111xxxxx001000xxxxxxxxxx
7102                                                                     ldeoral.  */
7103                                                                  return 1077;
7104                                                                }
7105                                                            }
7106                                                        }
7107                                                    }
7108                                                  else
7109                                                    {
7110                                                      if (((word >> 22) & 0x1) == 0)
7111                                                        {
7112                                                          if (((word >> 23) & 0x1) == 0)
7113                                                            {
7114                                                              if (((word >> 30) & 0x1) == 0)
7115                                                                {
7116                                                                  /* 33222222222211111111110000000000
7117                                                                     10987654321098765432109876543210
7118                                                                     x0111000001xxxxx101000xxxxxxxxxx
7119                                                                     rcwswp.  */
7120                                                                  return 3255;
7121                                                                }
7122                                                              else
7123                                                                {
7124                                                                  if (((word >> 31) & 0x1) == 0)
7125                                                                    {
7126                                                                      /* 33222222222211111111110000000000
7127                                                                         10987654321098765432109876543210
7128                                                                         01111000001xxxxx101000xxxxxxxxxx
7129                                                                         rcwsswp.  */
7130                                                                      return 3263;
7131                                                                    }
7132                                                                  else
7133                                                                    {
7134                                                                      /* 33222222222211111111110000000000
7135                                                                         10987654321098765432109876543210
7136                                                                         11111000001xxxxx101000xxxxxxxxxx
7137                                                                         st64bv0.  */
7138                                                                      return 994;
7139                                                                    }
7140                                                                }
7141                                                            }
7142                                                          else
7143                                                            {
7144                                                              if (((word >> 30) & 0x1) == 0)
7145                                                                {
7146                                                                  /* 33222222222211111111110000000000
7147                                                                     10987654321098765432109876543210
7148                                                                     x0111000101xxxxx101000xxxxxxxxxx
7149                                                                     rcwswpa.  */
7150                                                                  return 3256;
7151                                                                }
7152                                                              else
7153                                                                {
7154                                                                  /* 33222222222211111111110000000000
7155                                                                     10987654321098765432109876543210
7156                                                                     x1111000101xxxxx101000xxxxxxxxxx
7157                                                                     rcwsswpa.  */
7158                                                                  return 3264;
7159                                                                }
7160                                                            }
7161                                                        }
7162                                                      else
7163                                                        {
7164                                                          if (((word >> 23) & 0x1) == 0)
7165                                                            {
7166                                                              if (((word >> 30) & 0x1) == 0)
7167                                                                {
7168                                                                  /* 33222222222211111111110000000000
7169                                                                     10987654321098765432109876543210
7170                                                                     x0111000011xxxxx101000xxxxxxxxxx
7171                                                                     rcwswpl.  */
7172                                                                  return 3258;
7173                                                                }
7174                                                              else
7175                                                                {
7176                                                                  /* 33222222222211111111110000000000
7177                                                                     10987654321098765432109876543210
7178                                                                     x1111000011xxxxx101000xxxxxxxxxx
7179                                                                     rcwsswpl.  */
7180                                                                  return 3266;
7181                                                                }
7182                                                            }
7183                                                          else
7184                                                            {
7185                                                              if (((word >> 30) & 0x1) == 0)
7186                                                                {
7187                                                                  /* 33222222222211111111110000000000
7188                                                                     10987654321098765432109876543210
7189                                                                     x0111000111xxxxx101000xxxxxxxxxx
7190                                                                     rcwswpal.  */
7191                                                                  return 3257;
7192                                                                }
7193                                                              else
7194                                                                {
7195                                                                  /* 33222222222211111111110000000000
7196                                                                     10987654321098765432109876543210
7197                                                                     x1111000111xxxxx101000xxxxxxxxxx
7198                                                                     rcwsswpal.  */
7199                                                                  return 3265;
7200                                                                }
7201                                                            }
7202                                                        }
7203                                                    }
7204                                                }
7205                                              else
7206                                                {
7207                                                  if (((word >> 22) & 0x1) == 0)
7208                                                    {
7209                                                      if (((word >> 23) & 0x1) == 0)
7210                                                        {
7211                                                          if (((word >> 31) & 0x1) == 0)
7212                                                            {
7213                                                              if (((word >> 30) & 0x1) == 0)
7214                                                                {
7215                                                                  /* 33222222222211111111110000000000
7216                                                                     10987654321098765432109876543210
7217                                                                     00111000001xxxxxx11000xxxxxxxxxx
7218                                                                     ldumaxb.  */
7219                                                                  return 1114;
7220                                                                }
7221                                                              else
7222                                                                {
7223                                                                  /* 33222222222211111111110000000000
7224                                                                     10987654321098765432109876543210
7225                                                                     01111000001xxxxxx11000xxxxxxxxxx
7226                                                                     ldumaxh.  */
7227                                                                  return 1115;
7228                                                                }
7229                                                            }
7230                                                          else
7231                                                            {
7232                                                              /* 33222222222211111111110000000000
7233                                                                 10987654321098765432109876543210
7234                                                                 1x111000001xxxxxx11000xxxxxxxxxx
7235                                                                 ldumax.  */
7236                                                              return 1116;
7237                                                            }
7238                                                        }
7239                                                      else
7240                                                        {
7241                                                          if (((word >> 31) & 0x1) == 0)
7242                                                            {
7243                                                              if (((word >> 30) & 0x1) == 0)
7244                                                                {
7245                                                                  /* 33222222222211111111110000000000
7246                                                                     10987654321098765432109876543210
7247                                                                     00111000101xxxxxx11000xxxxxxxxxx
7248                                                                     ldumaxab.  */
7249                                                                  return 1117;
7250                                                                }
7251                                                              else
7252                                                                {
7253                                                                  /* 33222222222211111111110000000000
7254                                                                     10987654321098765432109876543210
7255                                                                     01111000101xxxxxx11000xxxxxxxxxx
7256                                                                     ldumaxah.  */
7257                                                                  return 1120;
7258                                                                }
7259                                                            }
7260                                                          else
7261                                                            {
7262                                                              /* 33222222222211111111110000000000
7263                                                                 10987654321098765432109876543210
7264                                                                 1x111000101xxxxxx11000xxxxxxxxxx
7265                                                                 ldumaxa.  */
7266                                                              return 1123;
7267                                                            }
7268                                                        }
7269                                                    }
7270                                                  else
7271                                                    {
7272                                                      if (((word >> 23) & 0x1) == 0)
7273                                                        {
7274                                                          if (((word >> 31) & 0x1) == 0)
7275                                                            {
7276                                                              if (((word >> 30) & 0x1) == 0)
7277                                                                {
7278                                                                  /* 33222222222211111111110000000000
7279                                                                     10987654321098765432109876543210
7280                                                                     00111000011xxxxxx11000xxxxxxxxxx
7281                                                                     ldumaxlb.  */
7282                                                                  return 1118;
7283                                                                }
7284                                                              else
7285                                                                {
7286                                                                  /* 33222222222211111111110000000000
7287                                                                     10987654321098765432109876543210
7288                                                                     01111000011xxxxxx11000xxxxxxxxxx
7289                                                                     ldumaxlh.  */
7290                                                                  return 1121;
7291                                                                }
7292                                                            }
7293                                                          else
7294                                                            {
7295                                                              /* 33222222222211111111110000000000
7296                                                                 10987654321098765432109876543210
7297                                                                 1x111000011xxxxxx11000xxxxxxxxxx
7298                                                                 ldumaxl.  */
7299                                                              return 1124;
7300                                                            }
7301                                                        }
7302                                                      else
7303                                                        {
7304                                                          if (((word >> 31) & 0x1) == 0)
7305                                                            {
7306                                                              if (((word >> 30) & 0x1) == 0)
7307                                                                {
7308                                                                  /* 33222222222211111111110000000000
7309                                                                     10987654321098765432109876543210
7310                                                                     00111000111xxxxxx11000xxxxxxxxxx
7311                                                                     ldumaxalb.  */
7312                                                                  return 1119;
7313                                                                }
7314                                                              else
7315                                                                {
7316                                                                  /* 33222222222211111111110000000000
7317                                                                     10987654321098765432109876543210
7318                                                                     01111000111xxxxxx11000xxxxxxxxxx
7319                                                                     ldumaxalh.  */
7320                                                                  return 1122;
7321                                                                }
7322                                                            }
7323                                                          else
7324                                                            {
7325                                                              /* 33222222222211111111110000000000
7326                                                                 10987654321098765432109876543210
7327                                                                 1x111000111xxxxxx11000xxxxxxxxxx
7328                                                                 ldumaxal.  */
7329                                                              return 1125;
7330                                                            }
7331                                                        }
7332                                                    }
7333                                                }
7334                                            }
7335                                        }
7336                                      else
7337                                        {
7338                                          if (((word >> 13) & 0x1) == 0)
7339                                            {
7340                                              if (((word >> 14) & 0x1) == 0)
7341                                                {
7342                                                  if (((word >> 15) & 0x1) == 0)
7343                                                    {
7344                                                      if (((word >> 22) & 0x1) == 0)
7345                                                        {
7346                                                          if (((word >> 23) & 0x1) == 0)
7347                                                            {
7348                                                              if (((word >> 31) & 0x1) == 0)
7349                                                                {
7350                                                                  if (((word >> 30) & 0x1) == 0)
7351                                                                    {
7352                                                                      /* 33222222222211111111110000000000
7353                                                                         10987654321098765432109876543210
7354                                                                         00111000001xxxxx000100xxxxxxxxxx
7355                                                                         ldclrb.  */
7356                                                                      return 1054;
7357                                                                    }
7358                                                                  else
7359                                                                    {
7360                                                                      /* 33222222222211111111110000000000
7361                                                                         10987654321098765432109876543210
7362                                                                         01111000001xxxxx000100xxxxxxxxxx
7363                                                                         ldclrh.  */
7364                                                                      return 1055;
7365                                                                    }
7366                                                                }
7367                                                              else
7368                                                                {
7369                                                                  /* 33222222222211111111110000000000
7370                                                                     10987654321098765432109876543210
7371                                                                     1x111000001xxxxx000100xxxxxxxxxx
7372                                                                     ldclr.  */
7373                                                                  return 1056;
7374                                                                }
7375                                                            }
7376                                                          else
7377                                                            {
7378                                                              if (((word >> 31) & 0x1) == 0)
7379                                                                {
7380                                                                  if (((word >> 30) & 0x1) == 0)
7381                                                                    {
7382                                                                      /* 33222222222211111111110000000000
7383                                                                         10987654321098765432109876543210
7384                                                                         00111000101xxxxx000100xxxxxxxxxx
7385                                                                         ldclrab.  */
7386                                                                      return 1057;
7387                                                                    }
7388                                                                  else
7389                                                                    {
7390                                                                      /* 33222222222211111111110000000000
7391                                                                         10987654321098765432109876543210
7392                                                                         01111000101xxxxx000100xxxxxxxxxx
7393                                                                         ldclrah.  */
7394                                                                      return 1060;
7395                                                                    }
7396                                                                }
7397                                                              else
7398                                                                {
7399                                                                  /* 33222222222211111111110000000000
7400                                                                     10987654321098765432109876543210
7401                                                                     1x111000101xxxxx000100xxxxxxxxxx
7402                                                                     ldclra.  */
7403                                                                  return 1063;
7404                                                                }
7405                                                            }
7406                                                        }
7407                                                      else
7408                                                        {
7409                                                          if (((word >> 23) & 0x1) == 0)
7410                                                            {
7411                                                              if (((word >> 31) & 0x1) == 0)
7412                                                                {
7413                                                                  if (((word >> 30) & 0x1) == 0)
7414                                                                    {
7415                                                                      /* 33222222222211111111110000000000
7416                                                                         10987654321098765432109876543210
7417                                                                         00111000011xxxxx000100xxxxxxxxxx
7418                                                                         ldclrlb.  */
7419                                                                      return 1058;
7420                                                                    }
7421                                                                  else
7422                                                                    {
7423                                                                      /* 33222222222211111111110000000000
7424                                                                         10987654321098765432109876543210
7425                                                                         01111000011xxxxx000100xxxxxxxxxx
7426                                                                         ldclrlh.  */
7427                                                                      return 1061;
7428                                                                    }
7429                                                                }
7430                                                              else
7431                                                                {
7432                                                                  /* 33222222222211111111110000000000
7433                                                                     10987654321098765432109876543210
7434                                                                     1x111000011xxxxx000100xxxxxxxxxx
7435                                                                     ldclrl.  */
7436                                                                  return 1064;
7437                                                                }
7438                                                            }
7439                                                          else
7440                                                            {
7441                                                              if (((word >> 31) & 0x1) == 0)
7442                                                                {
7443                                                                  if (((word >> 30) & 0x1) == 0)
7444                                                                    {
7445                                                                      /* 33222222222211111111110000000000
7446                                                                         10987654321098765432109876543210
7447                                                                         00111000111xxxxx000100xxxxxxxxxx
7448                                                                         ldclralb.  */
7449                                                                      return 1059;
7450                                                                    }
7451                                                                  else
7452                                                                    {
7453                                                                      /* 33222222222211111111110000000000
7454                                                                         10987654321098765432109876543210
7455                                                                         01111000111xxxxx000100xxxxxxxxxx
7456                                                                         ldclralh.  */
7457                                                                      return 1062;
7458                                                                    }
7459                                                                }
7460                                                              else
7461                                                                {
7462                                                                  /* 33222222222211111111110000000000
7463                                                                     10987654321098765432109876543210
7464                                                                     1x111000111xxxxx000100xxxxxxxxxx
7465                                                                     ldclral.  */
7466                                                                  return 1065;
7467                                                                }
7468                                                            }
7469                                                        }
7470                                                    }
7471                                                  else
7472                                                    {
7473                                                      if (((word >> 22) & 0x1) == 0)
7474                                                        {
7475                                                          if (((word >> 23) & 0x1) == 0)
7476                                                            {
7477                                                              if (((word >> 30) & 0x1) == 0)
7478                                                                {
7479                                                                  /* 33222222222211111111110000000000
7480                                                                     10987654321098765432109876543210
7481                                                                     x0111000001xxxxx100100xxxxxxxxxx
7482                                                                     rcwclr.  */
7483                                                                  return 3223;
7484                                                                }
7485                                                              else
7486                                                                {
7487                                                                  if (((word >> 31) & 0x1) == 0)
7488                                                                    {
7489                                                                      /* 33222222222211111111110000000000
7490                                                                         10987654321098765432109876543210
7491                                                                         01111000001xxxxx100100xxxxxxxxxx
7492                                                                         rcwsclr.  */
7493                                                                      return 3231;
7494                                                                    }
7495                                                                  else
7496                                                                    {
7497                                                                      /* 33222222222211111111110000000000
7498                                                                         10987654321098765432109876543210
7499                                                                         11111000001xxxxx100100xxxxxxxxxx
7500                                                                         st64b.  */
7501                                                                      return 992;
7502                                                                    }
7503                                                                }
7504                                                            }
7505                                                          else
7506                                                            {
7507                                                              if (((word >> 30) & 0x1) == 0)
7508                                                                {
7509                                                                  /* 33222222222211111111110000000000
7510                                                                     10987654321098765432109876543210
7511                                                                     x0111000101xxxxx100100xxxxxxxxxx
7512                                                                     rcwclra.  */
7513                                                                  return 3224;
7514                                                                }
7515                                                              else
7516                                                                {
7517                                                                  /* 33222222222211111111110000000000
7518                                                                     10987654321098765432109876543210
7519                                                                     x1111000101xxxxx100100xxxxxxxxxx
7520                                                                     rcwsclra.  */
7521                                                                  return 3232;
7522                                                                }
7523                                                            }
7524                                                        }
7525                                                      else
7526                                                        {
7527                                                          if (((word >> 23) & 0x1) == 0)
7528                                                            {
7529                                                              if (((word >> 30) & 0x1) == 0)
7530                                                                {
7531                                                                  /* 33222222222211111111110000000000
7532                                                                     10987654321098765432109876543210
7533                                                                     x0111000011xxxxx100100xxxxxxxxxx
7534                                                                     rcwclrl.  */
7535                                                                  return 3226;
7536                                                                }
7537                                                              else
7538                                                                {
7539                                                                  /* 33222222222211111111110000000000
7540                                                                     10987654321098765432109876543210
7541                                                                     x1111000011xxxxx100100xxxxxxxxxx
7542                                                                     rcwsclrl.  */
7543                                                                  return 3234;
7544                                                                }
7545                                                            }
7546                                                          else
7547                                                            {
7548                                                              if (((word >> 30) & 0x1) == 0)
7549                                                                {
7550                                                                  /* 33222222222211111111110000000000
7551                                                                     10987654321098765432109876543210
7552                                                                     x0111000111xxxxx100100xxxxxxxxxx
7553                                                                     rcwclral.  */
7554                                                                  return 3225;
7555                                                                }
7556                                                              else
7557                                                                {
7558                                                                  /* 33222222222211111111110000000000
7559                                                                     10987654321098765432109876543210
7560                                                                     x1111000111xxxxx100100xxxxxxxxxx
7561                                                                     rcwsclral.  */
7562                                                                  return 3233;
7563                                                                }
7564                                                            }
7565                                                        }
7566                                                    }
7567                                                }
7568                                              else
7569                                                {
7570                                                  if (((word >> 15) & 0x1) == 0)
7571                                                    {
7572                                                      if (((word >> 22) & 0x1) == 0)
7573                                                        {
7574                                                          if (((word >> 23) & 0x1) == 0)
7575                                                            {
7576                                                              if (((word >> 31) & 0x1) == 0)
7577                                                                {
7578                                                                  if (((word >> 30) & 0x1) == 0)
7579                                                                    {
7580                                                                      /* 33222222222211111111110000000000
7581                                                                         10987654321098765432109876543210
7582                                                                         00111000001xxxxx010100xxxxxxxxxx
7583                                                                         ldsminb.  */
7584                                                                      return 1102;
7585                                                                    }
7586                                                                  else
7587                                                                    {
7588                                                                      /* 33222222222211111111110000000000
7589                                                                         10987654321098765432109876543210
7590                                                                         01111000001xxxxx010100xxxxxxxxxx
7591                                                                         ldsminh.  */
7592                                                                      return 1103;
7593                                                                    }
7594                                                                }
7595                                                              else
7596                                                                {
7597                                                                  /* 33222222222211111111110000000000
7598                                                                     10987654321098765432109876543210
7599                                                                     1x111000001xxxxx010100xxxxxxxxxx
7600                                                                     ldsmin.  */
7601                                                                  return 1104;
7602                                                                }
7603                                                            }
7604                                                          else
7605                                                            {
7606                                                              if (((word >> 31) & 0x1) == 0)
7607                                                                {
7608                                                                  if (((word >> 30) & 0x1) == 0)
7609                                                                    {
7610                                                                      /* 33222222222211111111110000000000
7611                                                                         10987654321098765432109876543210
7612                                                                         00111000101xxxxx010100xxxxxxxxxx
7613                                                                         ldsminab.  */
7614                                                                      return 1105;
7615                                                                    }
7616                                                                  else
7617                                                                    {
7618                                                                      /* 33222222222211111111110000000000
7619                                                                         10987654321098765432109876543210
7620                                                                         01111000101xxxxx010100xxxxxxxxxx
7621                                                                         ldsminah.  */
7622                                                                      return 1108;
7623                                                                    }
7624                                                                }
7625                                                              else
7626                                                                {
7627                                                                  /* 33222222222211111111110000000000
7628                                                                     10987654321098765432109876543210
7629                                                                     1x111000101xxxxx010100xxxxxxxxxx
7630                                                                     ldsmina.  */
7631                                                                  return 1111;
7632                                                                }
7633                                                            }
7634                                                        }
7635                                                      else
7636                                                        {
7637                                                          if (((word >> 23) & 0x1) == 0)
7638                                                            {
7639                                                              if (((word >> 31) & 0x1) == 0)
7640                                                                {
7641                                                                  if (((word >> 30) & 0x1) == 0)
7642                                                                    {
7643                                                                      /* 33222222222211111111110000000000
7644                                                                         10987654321098765432109876543210
7645                                                                         00111000011xxxxx010100xxxxxxxxxx
7646                                                                         ldsminlb.  */
7647                                                                      return 1106;
7648                                                                    }
7649                                                                  else
7650                                                                    {
7651                                                                      /* 33222222222211111111110000000000
7652                                                                         10987654321098765432109876543210
7653                                                                         01111000011xxxxx010100xxxxxxxxxx
7654                                                                         ldsminlh.  */
7655                                                                      return 1109;
7656                                                                    }
7657                                                                }
7658                                                              else
7659                                                                {
7660                                                                  /* 33222222222211111111110000000000
7661                                                                     10987654321098765432109876543210
7662                                                                     1x111000011xxxxx010100xxxxxxxxxx
7663                                                                     ldsminl.  */
7664                                                                  return 1112;
7665                                                                }
7666                                                            }
7667                                                          else
7668                                                            {
7669                                                              if (((word >> 31) & 0x1) == 0)
7670                                                                {
7671                                                                  if (((word >> 30) & 0x1) == 0)
7672                                                                    {
7673                                                                      /* 33222222222211111111110000000000
7674                                                                         10987654321098765432109876543210
7675                                                                         00111000111xxxxx010100xxxxxxxxxx
7676                                                                         ldsminalb.  */
7677                                                                      return 1107;
7678                                                                    }
7679                                                                  else
7680                                                                    {
7681                                                                      /* 33222222222211111111110000000000
7682                                                                         10987654321098765432109876543210
7683                                                                         01111000111xxxxx010100xxxxxxxxxx
7684                                                                         ldsminalh.  */
7685                                                                      return 1110;
7686                                                                    }
7687                                                                }
7688                                                              else
7689                                                                {
7690                                                                  /* 33222222222211111111110000000000
7691                                                                     10987654321098765432109876543210
7692                                                                     1x111000111xxxxx010100xxxxxxxxxx
7693                                                                     ldsminal.  */
7694                                                                  return 1113;
7695                                                                }
7696                                                            }
7697                                                        }
7698                                                    }
7699                                                  else
7700                                                    {
7701                                                      /* 33222222222211111111110000000000
7702                                                         10987654321098765432109876543210
7703                                                         xx111000xx1xxxxx110100xxxxxxxxxx
7704                                                         ld64b.  */
7705                                                      return 991;
7706                                                    }
7707                                                }
7708                                            }
7709                                          else
7710                                            {
7711                                              if (((word >> 14) & 0x1) == 0)
7712                                                {
7713                                                  if (((word >> 15) & 0x1) == 0)
7714                                                    {
7715                                                      if (((word >> 22) & 0x1) == 0)
7716                                                        {
7717                                                          if (((word >> 23) & 0x1) == 0)
7718                                                            {
7719                                                              if (((word >> 31) & 0x1) == 0)
7720                                                                {
7721                                                                  if (((word >> 30) & 0x1) == 0)
7722                                                                    {
7723                                                                      /* 33222222222211111111110000000000
7724                                                                         10987654321098765432109876543210
7725                                                                         00111000001xxxxx001100xxxxxxxxxx
7726                                                                         ldsetb.  */
7727                                                                      return 1078;
7728                                                                    }
7729                                                                  else
7730                                                                    {
7731                                                                      /* 33222222222211111111110000000000
7732                                                                         10987654321098765432109876543210
7733                                                                         01111000001xxxxx001100xxxxxxxxxx
7734                                                                         ldseth.  */
7735                                                                      return 1079;
7736                                                                    }
7737                                                                }
7738                                                              else
7739                                                                {
7740                                                                  /* 33222222222211111111110000000000
7741                                                                     10987654321098765432109876543210
7742                                                                     1x111000001xxxxx001100xxxxxxxxxx
7743                                                                     ldset.  */
7744                                                                  return 1080;
7745                                                                }
7746                                                            }
7747                                                          else
7748                                                            {
7749                                                              if (((word >> 31) & 0x1) == 0)
7750                                                                {
7751                                                                  if (((word >> 30) & 0x1) == 0)
7752                                                                    {
7753                                                                      /* 33222222222211111111110000000000
7754                                                                         10987654321098765432109876543210
7755                                                                         00111000101xxxxx001100xxxxxxxxxx
7756                                                                         ldsetab.  */
7757                                                                      return 1081;
7758                                                                    }
7759                                                                  else
7760                                                                    {
7761                                                                      /* 33222222222211111111110000000000
7762                                                                         10987654321098765432109876543210
7763                                                                         01111000101xxxxx001100xxxxxxxxxx
7764                                                                         ldsetah.  */
7765                                                                      return 1084;
7766                                                                    }
7767                                                                }
7768                                                              else
7769                                                                {
7770                                                                  /* 33222222222211111111110000000000
7771                                                                     10987654321098765432109876543210
7772                                                                     1x111000101xxxxx001100xxxxxxxxxx
7773                                                                     ldseta.  */
7774                                                                  return 1087;
7775                                                                }
7776                                                            }
7777                                                        }
7778                                                      else
7779                                                        {
7780                                                          if (((word >> 23) & 0x1) == 0)
7781                                                            {
7782                                                              if (((word >> 31) & 0x1) == 0)
7783                                                                {
7784                                                                  if (((word >> 30) & 0x1) == 0)
7785                                                                    {
7786                                                                      /* 33222222222211111111110000000000
7787                                                                         10987654321098765432109876543210
7788                                                                         00111000011xxxxx001100xxxxxxxxxx
7789                                                                         ldsetlb.  */
7790                                                                      return 1082;
7791                                                                    }
7792                                                                  else
7793                                                                    {
7794                                                                      /* 33222222222211111111110000000000
7795                                                                         10987654321098765432109876543210
7796                                                                         01111000011xxxxx001100xxxxxxxxxx
7797                                                                         ldsetlh.  */
7798                                                                      return 1085;
7799                                                                    }
7800                                                                }
7801                                                              else
7802                                                                {
7803                                                                  /* 33222222222211111111110000000000
7804                                                                     10987654321098765432109876543210
7805                                                                     1x111000011xxxxx001100xxxxxxxxxx
7806                                                                     ldsetl.  */
7807                                                                  return 1088;
7808                                                                }
7809                                                            }
7810                                                          else
7811                                                            {
7812                                                              if (((word >> 31) & 0x1) == 0)
7813                                                                {
7814                                                                  if (((word >> 30) & 0x1) == 0)
7815                                                                    {
7816                                                                      /* 33222222222211111111110000000000
7817                                                                         10987654321098765432109876543210
7818                                                                         00111000111xxxxx001100xxxxxxxxxx
7819                                                                         ldsetalb.  */
7820                                                                      return 1083;
7821                                                                    }
7822                                                                  else
7823                                                                    {
7824                                                                      /* 33222222222211111111110000000000
7825                                                                         10987654321098765432109876543210
7826                                                                         01111000111xxxxx001100xxxxxxxxxx
7827                                                                         ldsetalh.  */
7828                                                                      return 1086;
7829                                                                    }
7830                                                                }
7831                                                              else
7832                                                                {
7833                                                                  /* 33222222222211111111110000000000
7834                                                                     10987654321098765432109876543210
7835                                                                     1x111000111xxxxx001100xxxxxxxxxx
7836                                                                     ldsetal.  */
7837                                                                  return 1089;
7838                                                                }
7839                                                            }
7840                                                        }
7841                                                    }
7842                                                  else
7843                                                    {
7844                                                      if (((word >> 22) & 0x1) == 0)
7845                                                        {
7846                                                          if (((word >> 23) & 0x1) == 0)
7847                                                            {
7848                                                              if (((word >> 30) & 0x1) == 0)
7849                                                                {
7850                                                                  /* 33222222222211111111110000000000
7851                                                                     10987654321098765432109876543210
7852                                                                     x0111000001xxxxx101100xxxxxxxxxx
7853                                                                     rcwset.  */
7854                                                                  return 3239;
7855                                                                }
7856                                                              else
7857                                                                {
7858                                                                  if (((word >> 31) & 0x1) == 0)
7859                                                                    {
7860                                                                      /* 33222222222211111111110000000000
7861                                                                         10987654321098765432109876543210
7862                                                                         01111000001xxxxx101100xxxxxxxxxx
7863                                                                         rcwsset.  */
7864                                                                      return 3247;
7865                                                                    }
7866                                                                  else
7867                                                                    {
7868                                                                      /* 33222222222211111111110000000000
7869                                                                         10987654321098765432109876543210
7870                                                                         11111000001xxxxx101100xxxxxxxxxx
7871                                                                         st64bv.  */
7872                                                                      return 993;
7873                                                                    }
7874                                                                }
7875                                                            }
7876                                                          else
7877                                                            {
7878                                                              if (((word >> 30) & 0x1) == 0)
7879                                                                {
7880                                                                  /* 33222222222211111111110000000000
7881                                                                     10987654321098765432109876543210
7882                                                                     x0111000101xxxxx101100xxxxxxxxxx
7883                                                                     rcwseta.  */
7884                                                                  return 3240;
7885                                                                }
7886                                                              else
7887                                                                {
7888                                                                  /* 33222222222211111111110000000000
7889                                                                     10987654321098765432109876543210
7890                                                                     x1111000101xxxxx101100xxxxxxxxxx
7891                                                                     rcwsseta.  */
7892                                                                  return 3248;
7893                                                                }
7894                                                            }
7895                                                        }
7896                                                      else
7897                                                        {
7898                                                          if (((word >> 23) & 0x1) == 0)
7899                                                            {
7900                                                              if (((word >> 30) & 0x1) == 0)
7901                                                                {
7902                                                                  /* 33222222222211111111110000000000
7903                                                                     10987654321098765432109876543210
7904                                                                     x0111000011xxxxx101100xxxxxxxxxx
7905                                                                     rcwsetl.  */
7906                                                                  return 3242;
7907                                                                }
7908                                                              else
7909                                                                {
7910                                                                  /* 33222222222211111111110000000000
7911                                                                     10987654321098765432109876543210
7912                                                                     x1111000011xxxxx101100xxxxxxxxxx
7913                                                                     rcwssetl.  */
7914                                                                  return 3250;
7915                                                                }
7916                                                            }
7917                                                          else
7918                                                            {
7919                                                              if (((word >> 30) & 0x1) == 0)
7920                                                                {
7921                                                                  /* 33222222222211111111110000000000
7922                                                                     10987654321098765432109876543210
7923                                                                     x0111000111xxxxx101100xxxxxxxxxx
7924                                                                     rcwsetal.  */
7925                                                                  return 3241;
7926                                                                }
7927                                                              else
7928                                                                {
7929                                                                  /* 33222222222211111111110000000000
7930                                                                     10987654321098765432109876543210
7931                                                                     x1111000111xxxxx101100xxxxxxxxxx
7932                                                                     rcwssetal.  */
7933                                                                  return 3249;
7934                                                                }
7935                                                            }
7936                                                        }
7937                                                    }
7938                                                }
7939                                              else
7940                                                {
7941                                                  if (((word >> 22) & 0x1) == 0)
7942                                                    {
7943                                                      if (((word >> 23) & 0x1) == 0)
7944                                                        {
7945                                                          if (((word >> 31) & 0x1) == 0)
7946                                                            {
7947                                                              if (((word >> 30) & 0x1) == 0)
7948                                                                {
7949                                                                  /* 33222222222211111111110000000000
7950                                                                     10987654321098765432109876543210
7951                                                                     00111000001xxxxxx11100xxxxxxxxxx
7952                                                                     lduminb.  */
7953                                                                  return 1126;
7954                                                                }
7955                                                              else
7956                                                                {
7957                                                                  /* 33222222222211111111110000000000
7958                                                                     10987654321098765432109876543210
7959                                                                     01111000001xxxxxx11100xxxxxxxxxx
7960                                                                     lduminh.  */
7961                                                                  return 1127;
7962                                                                }
7963                                                            }
7964                                                          else
7965                                                            {
7966                                                              /* 33222222222211111111110000000000
7967                                                                 10987654321098765432109876543210
7968                                                                 1x111000001xxxxxx11100xxxxxxxxxx
7969                                                                 ldumin.  */
7970                                                              return 1128;
7971                                                            }
7972                                                        }
7973                                                      else
7974                                                        {
7975                                                          if (((word >> 31) & 0x1) == 0)
7976                                                            {
7977                                                              if (((word >> 30) & 0x1) == 0)
7978                                                                {
7979                                                                  /* 33222222222211111111110000000000
7980                                                                     10987654321098765432109876543210
7981                                                                     00111000101xxxxxx11100xxxxxxxxxx
7982                                                                     lduminab.  */
7983                                                                  return 1129;
7984                                                                }
7985                                                              else
7986                                                                {
7987                                                                  /* 33222222222211111111110000000000
7988                                                                     10987654321098765432109876543210
7989                                                                     01111000101xxxxxx11100xxxxxxxxxx
7990                                                                     lduminah.  */
7991                                                                  return 1132;
7992                                                                }
7993                                                            }
7994                                                          else
7995                                                            {
7996                                                              /* 33222222222211111111110000000000
7997                                                                 10987654321098765432109876543210
7998                                                                 1x111000101xxxxxx11100xxxxxxxxxx
7999                                                                 ldumina.  */
8000                                                              return 1135;
8001                                                            }
8002                                                        }
8003                                                    }
8004                                                  else
8005                                                    {
8006                                                      if (((word >> 23) & 0x1) == 0)
8007                                                        {
8008                                                          if (((word >> 31) & 0x1) == 0)
8009                                                            {
8010                                                              if (((word >> 30) & 0x1) == 0)
8011                                                                {
8012                                                                  /* 33222222222211111111110000000000
8013                                                                     10987654321098765432109876543210
8014                                                                     00111000011xxxxxx11100xxxxxxxxxx
8015                                                                     lduminlb.  */
8016                                                                  return 1130;
8017                                                                }
8018                                                              else
8019                                                                {
8020                                                                  /* 33222222222211111111110000000000
8021                                                                     10987654321098765432109876543210
8022                                                                     01111000011xxxxxx11100xxxxxxxxxx
8023                                                                     lduminlh.  */
8024                                                                  return 1133;
8025                                                                }
8026                                                            }
8027                                                          else
8028                                                            {
8029                                                              /* 33222222222211111111110000000000
8030                                                                 10987654321098765432109876543210
8031                                                                 1x111000011xxxxxx11100xxxxxxxxxx
8032                                                                 lduminl.  */
8033                                                              return 1136;
8034                                                            }
8035                                                        }
8036                                                      else
8037                                                        {
8038                                                          if (((word >> 31) & 0x1) == 0)
8039                                                            {
8040                                                              if (((word >> 30) & 0x1) == 0)
8041                                                                {
8042                                                                  /* 33222222222211111111110000000000
8043                                                                     10987654321098765432109876543210
8044                                                                     00111000111xxxxxx11100xxxxxxxxxx
8045                                                                     lduminalb.  */
8046                                                                  return 1131;
8047                                                                }
8048                                                              else
8049                                                                {
8050                                                                  /* 33222222222211111111110000000000
8051                                                                     10987654321098765432109876543210
8052                                                                     01111000111xxxxxx11100xxxxxxxxxx
8053                                                                     lduminalh.  */
8054                                                                  return 1134;
8055                                                                }
8056                                                            }
8057                                                          else
8058                                                            {
8059                                                              /* 33222222222211111111110000000000
8060                                                                 10987654321098765432109876543210
8061                                                                 1x111000111xxxxxx11100xxxxxxxxxx
8062                                                                 lduminal.  */
8063                                                              return 1137;
8064                                                            }
8065                                                        }
8066                                                    }
8067                                                }
8068                                            }
8069                                        }
8070                                    }
8071                                }
8072                              else
8073                                {
8074                                  if (((word >> 21) & 0x1) == 0)
8075                                    {
8076                                      if (((word >> 23) & 0x1) == 0)
8077                                        {
8078                                          if (((word >> 22) & 0x1) == 0)
8079                                            {
8080                                              if (((word >> 31) & 0x1) == 0)
8081                                                {
8082                                                  if (((word >> 30) & 0x1) == 0)
8083                                                    {
8084                                                      /* 33222222222211111111110000000000
8085                                                         10987654321098765432109876543210
8086                                                         00111000000xxxxxxxxx10xxxxxxxxxx
8087                                                         sttrb.  */
8088                                                      return 913;
8089                                                    }
8090                                                  else
8091                                                    {
8092                                                      /* 33222222222211111111110000000000
8093                                                         10987654321098765432109876543210
8094                                                         01111000000xxxxxxxxx10xxxxxxxxxx
8095                                                         sttrh.  */
8096                                                      return 916;
8097                                                    }
8098                                                }
8099                                              else
8100                                                {
8101                                                  /* 33222222222211111111110000000000
8102                                                     10987654321098765432109876543210
8103                                                     1x111000000xxxxxxxxx10xxxxxxxxxx
8104                                                     sttr.  */
8105                                                  return 919;
8106                                                }
8107                                            }
8108                                          else
8109                                            {
8110                                              if (((word >> 31) & 0x1) == 0)
8111                                                {
8112                                                  if (((word >> 30) & 0x1) == 0)
8113                                                    {
8114                                                      /* 33222222222211111111110000000000
8115                                                         10987654321098765432109876543210
8116                                                         00111000010xxxxxxxxx10xxxxxxxxxx
8117                                                         ldtrb.  */
8118                                                      return 914;
8119                                                    }
8120                                                  else
8121                                                    {
8122                                                      /* 33222222222211111111110000000000
8123                                                         10987654321098765432109876543210
8124                                                         01111000010xxxxxxxxx10xxxxxxxxxx
8125                                                         ldtrh.  */
8126                                                      return 917;
8127                                                    }
8128                                                }
8129                                              else
8130                                                {
8131                                                  /* 33222222222211111111110000000000
8132                                                     10987654321098765432109876543210
8133                                                     1x111000010xxxxxxxxx10xxxxxxxxxx
8134                                                     ldtr.  */
8135                                                  return 920;
8136                                                }
8137                                            }
8138                                        }
8139                                      else
8140                                        {
8141                                          if (((word >> 30) & 0x1) == 0)
8142                                            {
8143                                              if (((word >> 31) & 0x1) == 0)
8144                                                {
8145                                                  /* 33222222222211111111110000000000
8146                                                     10987654321098765432109876543210
8147                                                     001110001x0xxxxxxxxx10xxxxxxxxxx
8148                                                     ldtrsb.  */
8149                                                  return 915;
8150                                                }
8151                                              else
8152                                                {
8153                                                  /* 33222222222211111111110000000000
8154                                                     10987654321098765432109876543210
8155                                                     101110001x0xxxxxxxxx10xxxxxxxxxx
8156                                                     ldtrsw.  */
8157                                                  return 921;
8158                                                }
8159                                            }
8160                                          else
8161                                            {
8162                                              /* 33222222222211111111110000000000
8163                                                 10987654321098765432109876543210
8164                                                 x11110001x0xxxxxxxxx10xxxxxxxxxx
8165                                                 ldtrsh.  */
8166                                              return 918;
8167                                            }
8168                                        }
8169                                    }
8170                                  else
8171                                    {
8172                                      if (((word >> 23) & 0x1) == 0)
8173                                        {
8174                                          if (((word >> 22) & 0x1) == 0)
8175                                            {
8176                                              if (((word >> 31) & 0x1) == 0)
8177                                                {
8178                                                  if (((word >> 30) & 0x1) == 0)
8179                                                    {
8180                                                      /* 33222222222211111111110000000000
8181                                                         10987654321098765432109876543210
8182                                                         00111000001xxxxxxxxx10xxxxxxxxxx
8183                                                         strb.  */
8184                                                      return 901;
8185                                                    }
8186                                                  else
8187                                                    {
8188                                                      /* 33222222222211111111110000000000
8189                                                         10987654321098765432109876543210
8190                                                         01111000001xxxxxxxxx10xxxxxxxxxx
8191                                                         strh.  */
8192                                                      return 906;
8193                                                    }
8194                                                }
8195                                              else
8196                                                {
8197                                                  /* 33222222222211111111110000000000
8198                                                     10987654321098765432109876543210
8199                                                     1x111000001xxxxxxxxx10xxxxxxxxxx
8200                                                     str.  */
8201                                                  return 909;
8202                                                }
8203                                            }
8204                                          else
8205                                            {
8206                                              if (((word >> 31) & 0x1) == 0)
8207                                                {
8208                                                  if (((word >> 30) & 0x1) == 0)
8209                                                    {
8210                                                      /* 33222222222211111111110000000000
8211                                                         10987654321098765432109876543210
8212                                                         00111000011xxxxxxxxx10xxxxxxxxxx
8213                                                         ldrb.  */
8214                                                      return 902;
8215                                                    }
8216                                                  else
8217                                                    {
8218                                                      /* 33222222222211111111110000000000
8219                                                         10987654321098765432109876543210
8220                                                         01111000011xxxxxxxxx10xxxxxxxxxx
8221                                                         ldrh.  */
8222                                                      return 907;
8223                                                    }
8224                                                }
8225                                              else
8226                                                {
8227                                                  /* 33222222222211111111110000000000
8228                                                     10987654321098765432109876543210
8229                                                     1x111000011xxxxxxxxx10xxxxxxxxxx
8230                                                     ldr.  */
8231                                                  return 910;
8232                                                }
8233                                            }
8234                                        }
8235                                      else
8236                                        {
8237                                          if (((word >> 30) & 0x1) == 0)
8238                                            {
8239                                              if (((word >> 31) & 0x1) == 0)
8240                                                {
8241                                                  /* 33222222222211111111110000000000
8242                                                     10987654321098765432109876543210
8243                                                     001110001x1xxxxxxxxx10xxxxxxxxxx
8244                                                     ldrsb.  */
8245                                                  return 903;
8246                                                }
8247                                              else
8248                                                {
8249                                                  /* 33222222222211111111110000000000
8250                                                     10987654321098765432109876543210
8251                                                     101110001x1xxxxxxxxx10xxxxxxxxxx
8252                                                     ldrsw.  */
8253                                                  return 911;
8254                                                }
8255                                            }
8256                                          else
8257                                            {
8258                                              if (((word >> 31) & 0x1) == 0)
8259                                                {
8260                                                  /* 33222222222211111111110000000000
8261                                                     10987654321098765432109876543210
8262                                                     011110001x1xxxxxxxxx10xxxxxxxxxx
8263                                                     ldrsh.  */
8264                                                  return 908;
8265                                                }
8266                                              else
8267                                                {
8268                                                  /* 33222222222211111111110000000000
8269                                                     10987654321098765432109876543210
8270                                                     111110001x1xxxxxxxxx10xxxxxxxxxx
8271                                                     prfm.  */
8272                                                  return 912;
8273                                                }
8274                                            }
8275                                        }
8276                                    }
8277                                }
8278                            }
8279                          else
8280                            {
8281                              if (((word >> 21) & 0x1) == 0)
8282                                {
8283                                  if (((word >> 23) & 0x1) == 0)
8284                                    {
8285                                      if (((word >> 22) & 0x1) == 0)
8286                                        {
8287                                          if (((word >> 31) & 0x1) == 0)
8288                                            {
8289                                              if (((word >> 30) & 0x1) == 0)
8290                                                {
8291                                                  /* 33222222222211111111110000000000
8292                                                     10987654321098765432109876543210
8293                                                     00111000000xxxxxxxxxx1xxxxxxxxxx
8294                                                     strb.  */
8295                                                  return 870;
8296                                                }
8297                                              else
8298                                                {
8299                                                  /* 33222222222211111111110000000000
8300                                                     10987654321098765432109876543210
8301                                                     01111000000xxxxxxxxxx1xxxxxxxxxx
8302                                                     strh.  */
8303                                                  return 875;
8304                                                }
8305                                            }
8306                                          else
8307                                            {
8308                                              /* 33222222222211111111110000000000
8309                                                 10987654321098765432109876543210
8310                                                 1x111000000xxxxxxxxxx1xxxxxxxxxx
8311                                                 str.  */
8312                                              return 878;
8313                                            }
8314                                        }
8315                                      else
8316                                        {
8317                                          if (((word >> 31) & 0x1) == 0)
8318                                            {
8319                                              if (((word >> 30) & 0x1) == 0)
8320                                                {
8321                                                  /* 33222222222211111111110000000000
8322                                                     10987654321098765432109876543210
8323                                                     00111000010xxxxxxxxxx1xxxxxxxxxx
8324                                                     ldrb.  */
8325                                                  return 871;
8326                                                }
8327                                              else
8328                                                {
8329                                                  /* 33222222222211111111110000000000
8330                                                     10987654321098765432109876543210
8331                                                     01111000010xxxxxxxxxx1xxxxxxxxxx
8332                                                     ldrh.  */
8333                                                  return 876;
8334                                                }
8335                                            }
8336                                          else
8337                                            {
8338                                              /* 33222222222211111111110000000000
8339                                                 10987654321098765432109876543210
8340                                                 1x111000010xxxxxxxxxx1xxxxxxxxxx
8341                                                 ldr.  */
8342                                              return 879;
8343                                            }
8344                                        }
8345                                    }
8346                                  else
8347                                    {
8348                                      if (((word >> 30) & 0x1) == 0)
8349                                        {
8350                                          if (((word >> 31) & 0x1) == 0)
8351                                            {
8352                                              /* 33222222222211111111110000000000
8353                                                 10987654321098765432109876543210
8354                                                 001110001x0xxxxxxxxxx1xxxxxxxxxx
8355                                                 ldrsb.  */
8356                                              return 872;
8357                                            }
8358                                          else
8359                                            {
8360                                              /* 33222222222211111111110000000000
8361                                                 10987654321098765432109876543210
8362                                                 101110001x0xxxxxxxxxx1xxxxxxxxxx
8363                                                 ldrsw.  */
8364                                              return 880;
8365                                            }
8366                                        }
8367                                      else
8368                                        {
8369                                          /* 33222222222211111111110000000000
8370                                             10987654321098765432109876543210
8371                                             x11110001x0xxxxxxxxxx1xxxxxxxxxx
8372                                             ldrsh.  */
8373                                          return 877;
8374                                        }
8375                                    }
8376                                }
8377                              else
8378                                {
8379                                  if (((word >> 23) & 0x1) == 0)
8380                                    {
8381                                      /* 33222222222211111111110000000000
8382                                         10987654321098765432109876543210
8383                                         xx1110000x1xxxxxxxxxx1xxxxxxxxxx
8384                                         ldraa.  */
8385                                      return 935;
8386                                    }
8387                                  else
8388                                    {
8389                                      /* 33222222222211111111110000000000
8390                                         10987654321098765432109876543210
8391                                         xx1110001x1xxxxxxxxxx1xxxxxxxxxx
8392                                         ldrab.  */
8393                                      return 936;
8394                                    }
8395                                }
8396                            }
8397                        }
8398                    }
8399                  else
8400                    {
8401                      if (((word >> 23) & 0x1) == 0)
8402                        {
8403                          if (((word >> 22) & 0x1) == 0)
8404                            {
8405                              if (((word >> 29) & 0x1) == 0)
8406                                {
8407                                  if (((word >> 10) & 0x1) == 0)
8408                                    {
8409                                      if (((word >> 11) & 0x1) == 0)
8410                                        {
8411                                          if (((word >> 21) & 0x1) == 0)
8412                                            {
8413                                              if (((word >> 30) & 0x1) == 0)
8414                                                {
8415                                                  if (((word >> 31) & 0x1) == 0)
8416                                                    {
8417                                                      /* 33222222222211111111110000000000
8418                                                         10987654321098765432109876543210
8419                                                         00011001000xxxxxxxxx00xxxxxxxxxx
8420                                                         stlurb.  */
8421                                                      return 3013;
8422                                                    }
8423                                                  else
8424                                                    {
8425                                                      /* 33222222222211111111110000000000
8426                                                         10987654321098765432109876543210
8427                                                         10011001000xxxxxxxxx00xxxxxxxxxx
8428                                                         stlur.  */
8429                                                      return 3021;
8430                                                    }
8431                                                }
8432                                              else
8433                                                {
8434                                                  if (((word >> 31) & 0x1) == 0)
8435                                                    {
8436                                                      /* 33222222222211111111110000000000
8437                                                         10987654321098765432109876543210
8438                                                         01011001000xxxxxxxxx00xxxxxxxxxx
8439                                                         stlurh.  */
8440                                                      return 3017;
8441                                                    }
8442                                                  else
8443                                                    {
8444                                                      /* 33222222222211111111110000000000
8445                                                         10987654321098765432109876543210
8446                                                         11011001000xxxxxxxxx00xxxxxxxxxx
8447                                                         stlur.  */
8448                                                      return 3024;
8449                                                    }
8450                                                }
8451                                            }
8452                                          else
8453                                            {
8454                                              if (((word >> 12) & 0x1) == 0)
8455                                                {
8456                                                  if (((word >> 13) & 0x1) == 0)
8457                                                    {
8458                                                      if (((word >> 15) & 0x1) == 0)
8459                                                        {
8460                                                          /* 33222222222211111111110000000000
8461                                                             10987654321098765432109876543210
8462                                                             xx011001001xxxxx0x0000xxxxxxxxxx
8463                                                             stzgm.  */
8464                                                          return 964;
8465                                                        }
8466                                                      else
8467                                                        {
8468                                                          /* 33222222222211111111110000000000
8469                                                             10987654321098765432109876543210
8470                                                             xx011001001xxxxx1x0000xxxxxxxxxx
8471                                                             swpp.  */
8472                                                          return 1194;
8473                                                        }
8474                                                    }
8475                                                  else
8476                                                    {
8477                                                      if (((word >> 30) & 0x1) == 0)
8478                                                        {
8479                                                          /* 33222222222211111111110000000000
8480                                                             10987654321098765432109876543210
8481                                                             x0011001001xxxxxxx1000xxxxxxxxxx
8482                                                             rcwswpp.  */
8483                                                          return 3259;
8484                                                        }
8485                                                      else
8486                                                        {
8487                                                          /* 33222222222211111111110000000000
8488                                                             10987654321098765432109876543210
8489                                                             x1011001001xxxxxxx1000xxxxxxxxxx
8490                                                             rcwsswpp.  */
8491                                                          return 3267;
8492                                                        }
8493                                                    }
8494                                                }
8495                                              else
8496                                                {
8497                                                  if (((word >> 13) & 0x1) == 0)
8498                                                    {
8499                                                      if (((word >> 15) & 0x1) == 0)
8500                                                        {
8501                                                          /* 33222222222211111111110000000000
8502                                                             10987654321098765432109876543210
8503                                                             xx011001001xxxxx0x0100xxxxxxxxxx
8504                                                             ldclrp.  */
8505                                                          return 1186;
8506                                                        }
8507                                                      else
8508                                                        {
8509                                                          if (((word >> 30) & 0x1) == 0)
8510                                                            {
8511                                                              /* 33222222222211111111110000000000
8512                                                                 10987654321098765432109876543210
8513                                                                 x0011001001xxxxx1x0100xxxxxxxxxx
8514                                                                 rcwclrp.  */
8515                                                              return 3227;
8516                                                            }
8517                                                          else
8518                                                            {
8519                                                              /* 33222222222211111111110000000000
8520                                                                 10987654321098765432109876543210
8521                                                                 x1011001001xxxxx1x0100xxxxxxxxxx
8522                                                                 rcwsclrp.  */
8523                                                              return 3235;
8524                                                            }
8525                                                        }
8526                                                    }
8527                                                  else
8528                                                    {
8529                                                      if (((word >> 15) & 0x1) == 0)
8530                                                        {
8531                                                          /* 33222222222211111111110000000000
8532                                                             10987654321098765432109876543210
8533                                                             xx011001001xxxxx0x1100xxxxxxxxxx
8534                                                             ldsetp.  */
8535                                                          return 1190;
8536                                                        }
8537                                                      else
8538                                                        {
8539                                                          if (((word >> 30) & 0x1) == 0)
8540                                                            {
8541                                                              /* 33222222222211111111110000000000
8542                                                                 10987654321098765432109876543210
8543                                                                 x0011001001xxxxx1x1100xxxxxxxxxx
8544                                                                 rcwsetp.  */
8545                                                              return 3243;
8546                                                            }
8547                                                          else
8548                                                            {
8549                                                              /* 33222222222211111111110000000000
8550                                                                 10987654321098765432109876543210
8551                                                                 x1011001001xxxxx1x1100xxxxxxxxxx
8552                                                                 rcwssetp.  */
8553                                                              return 3251;
8554                                                            }
8555                                                        }
8556                                                    }
8557                                                }
8558                                            }
8559                                        }
8560                                      else
8561                                        {
8562                                          if (((word >> 21) & 0x1) == 0)
8563                                            {
8564                                              /* 33222222222211111111110000000000
8565                                                 10987654321098765432109876543210
8566                                                 xx011001000xxxxxxxxx10xxxxxxxxxx
8567                                                 stilp.  */
8568                                              return 1199;
8569                                            }
8570                                          else
8571                                            {
8572                                              if (((word >> 30) & 0x1) == 0)
8573                                                {
8574                                                  /* 33222222222211111111110000000000
8575                                                     10987654321098765432109876543210
8576                                                     x0011001001xxxxxxxxx10xxxxxxxxxx
8577                                                     rcwcas.  */
8578                                                  return 3207;
8579                                                }
8580                                              else
8581                                                {
8582                                                  if (((word >> 31) & 0x1) == 0)
8583                                                    {
8584                                                      /* 33222222222211111111110000000000
8585                                                         10987654321098765432109876543210
8586                                                         01011001001xxxxxxxxx10xxxxxxxxxx
8587                                                         rcwscas.  */
8588                                                      return 3215;
8589                                                    }
8590                                                  else
8591                                                    {
8592                                                      /* 33222222222211111111110000000000
8593                                                         10987654321098765432109876543210
8594                                                         11011001001xxxxxxxxx10xxxxxxxxxx
8595                                                         stg.  */
8596                                                      return 881;
8597                                                    }
8598                                                }
8599                                            }
8600                                        }
8601                                    }
8602                                  else
8603                                    {
8604                                      if (((word >> 21) & 0x1) == 0)
8605                                        {
8606                                          if (((word >> 11) & 0x1) == 0)
8607                                            {
8608                                              if (((word >> 12) & 0x1) == 0)
8609                                                {
8610                                                  if (((word >> 13) & 0x1) == 0)
8611                                                    {
8612                                                      if (((word >> 14) & 0x1) == 0)
8613                                                        {
8614                                                          if (((word >> 15) & 0x1) == 0)
8615                                                            {
8616                                                              /* 33222222222211111111110000000000
8617                                                                 10987654321098765432109876543210
8618                                                                 xx011001000xxxxx000001xxxxxxxxxx
8619                                                                 cpyfp.  */
8620                                                              return 3073;
8621                                                            }
8622                                                          else
8623                                                            {
8624                                                              /* 33222222222211111111110000000000
8625                                                                 10987654321098765432109876543210
8626                                                                 xx011001000xxxxx100001xxxxxxxxxx
8627                                                                 cpyfprn.  */
8628                                                              return 3079;
8629                                                            }
8630                                                        }
8631                                                      else
8632                                                        {
8633                                                          if (((word >> 15) & 0x1) == 0)
8634                                                            {
8635                                                              /* 33222222222211111111110000000000
8636                                                                 10987654321098765432109876543210
8637                                                                 xx011001000xxxxx010001xxxxxxxxxx
8638                                                                 cpyfpwn.  */
8639                                                              return 3076;
8640                                                            }
8641                                                          else
8642                                                            {
8643                                                              /* 33222222222211111111110000000000
8644                                                                 10987654321098765432109876543210
8645                                                                 xx011001000xxxxx110001xxxxxxxxxx
8646                                                                 cpyfpn.  */
8647                                                              return 3082;
8648                                                            }
8649                                                        }
8650                                                    }
8651                                                  else
8652                                                    {
8653                                                      if (((word >> 14) & 0x1) == 0)
8654                                                        {
8655                                                          if (((word >> 15) & 0x1) == 0)
8656                                                            {
8657                                                              /* 33222222222211111111110000000000
8658                                                                 10987654321098765432109876543210
8659                                                                 xx011001000xxxxx001001xxxxxxxxxx
8660                                                                 cpyfprt.  */
8661                                                              return 3097;
8662                                                            }
8663                                                          else
8664                                                            {
8665                                                              /* 33222222222211111111110000000000
8666                                                                 10987654321098765432109876543210
8667                                                                 xx011001000xxxxx101001xxxxxxxxxx
8668                                                                 cpyfprtrn.  */
8669                                                              return 3103;
8670                                                            }
8671                                                        }
8672                                                      else
8673                                                        {
8674                                                          if (((word >> 15) & 0x1) == 0)
8675                                                            {
8676                                                              /* 33222222222211111111110000000000
8677                                                                 10987654321098765432109876543210
8678                                                                 xx011001000xxxxx011001xxxxxxxxxx
8679                                                                 cpyfprtwn.  */
8680                                                              return 3100;
8681                                                            }
8682                                                          else
8683                                                            {
8684                                                              /* 33222222222211111111110000000000
8685                                                                 10987654321098765432109876543210
8686                                                                 xx011001000xxxxx111001xxxxxxxxxx
8687                                                                 cpyfprtn.  */
8688                                                              return 3106;
8689                                                            }
8690                                                        }
8691                                                    }
8692                                                }
8693                                              else
8694                                                {
8695                                                  if (((word >> 13) & 0x1) == 0)
8696                                                    {
8697                                                      if (((word >> 14) & 0x1) == 0)
8698                                                        {
8699                                                          if (((word >> 15) & 0x1) == 0)
8700                                                            {
8701                                                              /* 33222222222211111111110000000000
8702                                                                 10987654321098765432109876543210
8703                                                                 xx011001000xxxxx000101xxxxxxxxxx
8704                                                                 cpyfpwt.  */
8705                                                              return 3085;
8706                                                            }
8707                                                          else
8708                                                            {
8709                                                              /* 33222222222211111111110000000000
8710                                                                 10987654321098765432109876543210
8711                                                                 xx011001000xxxxx100101xxxxxxxxxx
8712                                                                 cpyfpwtrn.  */
8713                                                              return 3091;
8714                                                            }
8715                                                        }
8716                                                      else
8717                                                        {
8718                                                          if (((word >> 15) & 0x1) == 0)
8719                                                            {
8720                                                              /* 33222222222211111111110000000000
8721                                                                 10987654321098765432109876543210
8722                                                                 xx011001000xxxxx010101xxxxxxxxxx
8723                                                                 cpyfpwtwn.  */
8724                                                              return 3088;
8725                                                            }
8726                                                          else
8727                                                            {
8728                                                              /* 33222222222211111111110000000000
8729                                                                 10987654321098765432109876543210
8730                                                                 xx011001000xxxxx110101xxxxxxxxxx
8731                                                                 cpyfpwtn.  */
8732                                                              return 3094;
8733                                                            }
8734                                                        }
8735                                                    }
8736                                                  else
8737                                                    {
8738                                                      if (((word >> 14) & 0x1) == 0)
8739                                                        {
8740                                                          if (((word >> 15) & 0x1) == 0)
8741                                                            {
8742                                                              /* 33222222222211111111110000000000
8743                                                                 10987654321098765432109876543210
8744                                                                 xx011001000xxxxx001101xxxxxxxxxx
8745                                                                 cpyfpt.  */
8746                                                              return 3109;
8747                                                            }
8748                                                          else
8749                                                            {
8750                                                              /* 33222222222211111111110000000000
8751                                                                 10987654321098765432109876543210
8752                                                                 xx011001000xxxxx101101xxxxxxxxxx
8753                                                                 cpyfptrn.  */
8754                                                              return 3115;
8755                                                            }
8756                                                        }
8757                                                      else
8758                                                        {
8759                                                          if (((word >> 15) & 0x1) == 0)
8760                                                            {
8761                                                              /* 33222222222211111111110000000000
8762                                                                 10987654321098765432109876543210
8763                                                                 xx011001000xxxxx011101xxxxxxxxxx
8764                                                                 cpyfptwn.  */
8765                                                              return 3112;
8766                                                            }
8767                                                          else
8768                                                            {
8769                                                              /* 33222222222211111111110000000000
8770                                                                 10987654321098765432109876543210
8771                                                                 xx011001000xxxxx111101xxxxxxxxxx
8772                                                                 cpyfptn.  */
8773                                                              return 3118;
8774                                                            }
8775                                                        }
8776                                                    }
8777                                                }
8778                                            }
8779                                          else
8780                                            {
8781                                              if (((word >> 12) & 0x1) == 0)
8782                                                {
8783                                                  /* 33222222222211111111110000000000
8784                                                     10987654321098765432109876543210
8785                                                     xx011001000xxxxxxxx011xxxxxxxxxx
8786                                                     gcsstr.  */
8787                                                  return 1259;
8788                                                }
8789                                              else
8790                                                {
8791                                                  /* 33222222222211111111110000000000
8792                                                     10987654321098765432109876543210
8793                                                     xx011001000xxxxxxxx111xxxxxxxxxx
8794                                                     gcssttr.  */
8795                                                  return 1260;
8796                                                }
8797                                            }
8798                                        }
8799                                      else
8800                                        {
8801                                          if (((word >> 30) & 0x1) == 0)
8802                                            {
8803                                              /* 33222222222211111111110000000000
8804                                                 10987654321098765432109876543210
8805                                                 x0011001001xxxxxxxxxx1xxxxxxxxxx
8806                                                 rcwcasp.  */
8807                                              return 3211;
8808                                            }
8809                                          else
8810                                            {
8811                                              if (((word >> 31) & 0x1) == 0)
8812                                                {
8813                                                  /* 33222222222211111111110000000000
8814                                                     10987654321098765432109876543210
8815                                                     01011001001xxxxxxxxxx1xxxxxxxxxx
8816                                                     rcwscasp.  */
8817                                                  return 3219;
8818                                                }
8819                                              else
8820                                                {
8821                                                  /* 33222222222211111111110000000000
8822                                                     10987654321098765432109876543210
8823                                                     11011001001xxxxxxxxxx1xxxxxxxxxx
8824                                                     stg.  */
8825                                                  return 885;
8826                                                }
8827                                            }
8828                                        }
8829                                    }
8830                                }
8831                              else
8832                                {
8833                                  if (((word >> 31) & 0x1) == 0)
8834                                    {
8835                                      if (((word >> 30) & 0x1) == 0)
8836                                        {
8837                                          /* 33222222222211111111110000000000
8838                                             10987654321098765432109876543210
8839                                             0011100100xxxxxxxxxxxxxxxxxxxxxx
8840                                             strb.  */
8841                                          return 889;
8842                                        }
8843                                      else
8844                                        {
8845                                          /* 33222222222211111111110000000000
8846                                             10987654321098765432109876543210
8847                                             0111100100xxxxxxxxxxxxxxxxxxxxxx
8848                                             strh.  */
8849                                          return 894;
8850                                        }
8851                                    }
8852                                  else
8853                                    {
8854                                      /* 33222222222211111111110000000000
8855                                         10987654321098765432109876543210
8856                                         1x11100100xxxxxxxxxxxxxxxxxxxxxx
8857                                         str.  */
8858                                      return 897;
8859                                    }
8860                                }
8861                            }
8862                          else
8863                            {
8864                              if (((word >> 29) & 0x1) == 0)
8865                                {
8866                                  if (((word >> 10) & 0x1) == 0)
8867                                    {
8868                                      if (((word >> 11) & 0x1) == 0)
8869                                        {
8870                                          if (((word >> 21) & 0x1) == 0)
8871                                            {
8872                                              if (((word >> 30) & 0x1) == 0)
8873                                                {
8874                                                  if (((word >> 31) & 0x1) == 0)
8875                                                    {
8876                                                      /* 33222222222211111111110000000000
8877                                                         10987654321098765432109876543210
8878                                                         00011001010xxxxxxxxx00xxxxxxxxxx
8879                                                         ldapurb.  */
8880                                                      return 3014;
8881                                                    }
8882                                                  else
8883                                                    {
8884                                                      /* 33222222222211111111110000000000
8885                                                         10987654321098765432109876543210
8886                                                         10011001010xxxxxxxxx00xxxxxxxxxx
8887                                                         ldapur.  */
8888                                                      return 3022;
8889                                                    }
8890                                                }
8891                                              else
8892                                                {
8893                                                  if (((word >> 31) & 0x1) == 0)
8894                                                    {
8895                                                      /* 33222222222211111111110000000000
8896                                                         10987654321098765432109876543210
8897                                                         01011001010xxxxxxxxx00xxxxxxxxxx
8898                                                         ldapurh.  */
8899                                                      return 3018;
8900                                                    }
8901                                                  else
8902                                                    {
8903                                                      /* 33222222222211111111110000000000
8904                                                         10987654321098765432109876543210
8905                                                         11011001010xxxxxxxxx00xxxxxxxxxx
8906                                                         ldapur.  */
8907                                                      return 3025;
8908                                                    }
8909                                                }
8910                                            }
8911                                          else
8912                                            {
8913                                              if (((word >> 30) & 0x1) == 0)
8914                                                {
8915                                                  if (((word >> 12) & 0x1) == 0)
8916                                                    {
8917                                                      if (((word >> 13) & 0x1) == 0)
8918                                                        {
8919                                                          /* 33222222222211111111110000000000
8920                                                             10987654321098765432109876543210
8921                                                             x0011001011xxxxxxx0000xxxxxxxxxx
8922                                                             swppl.  */
8923                                                          return 1197;
8924                                                        }
8925                                                      else
8926                                                        {
8927                                                          /* 33222222222211111111110000000000
8928                                                             10987654321098765432109876543210
8929                                                             x0011001011xxxxxxx1000xxxxxxxxxx
8930                                                             rcwswppl.  */
8931                                                          return 3262;
8932                                                        }
8933                                                    }
8934                                                  else
8935                                                    {
8936                                                      if (((word >> 13) & 0x1) == 0)
8937                                                        {
8938                                                          if (((word >> 15) & 0x1) == 0)
8939                                                            {
8940                                                              /* 33222222222211111111110000000000
8941                                                                 10987654321098765432109876543210
8942                                                                 x0011001011xxxxx0x0100xxxxxxxxxx
8943                                                                 ldclrpl.  */
8944                                                              return 1189;
8945                                                            }
8946                                                          else
8947                                                            {
8948                                                              /* 33222222222211111111110000000000
8949                                                                 10987654321098765432109876543210
8950                                                                 x0011001011xxxxx1x0100xxxxxxxxxx
8951                                                                 rcwclrpl.  */
8952                                                              return 3230;
8953                                                            }
8954                                                        }
8955                                                      else
8956                                                        {
8957                                                          if (((word >> 15) & 0x1) == 0)
8958                                                            {
8959                                                              /* 33222222222211111111110000000000
8960                                                                 10987654321098765432109876543210
8961                                                                 x0011001011xxxxx0x1100xxxxxxxxxx
8962                                                                 ldsetpl.  */
8963                                                              return 1193;
8964                                                            }
8965                                                          else
8966                                                            {
8967                                                              /* 33222222222211111111110000000000
8968                                                                 10987654321098765432109876543210
8969                                                                 x0011001011xxxxx1x1100xxxxxxxxxx
8970                                                                 rcwsetpl.  */
8971                                                              return 3246;
8972                                                            }
8973                                                        }
8974                                                    }
8975                                                }
8976                                              else
8977                                                {
8978                                                  if (((word >> 31) & 0x1) == 0)
8979                                                    {
8980                                                      if (((word >> 12) & 0x1) == 0)
8981                                                        {
8982                                                          /* 33222222222211111111110000000000
8983                                                             10987654321098765432109876543210
8984                                                             01011001011xxxxxxxx000xxxxxxxxxx
8985                                                             rcwsswppl.  */
8986                                                          return 3270;
8987                                                        }
8988                                                      else
8989                                                        {
8990                                                          if (((word >> 13) & 0x1) == 0)
8991                                                            {
8992                                                              /* 33222222222211111111110000000000
8993                                                                 10987654321098765432109876543210
8994                                                                 01011001011xxxxxxx0100xxxxxxxxxx
8995                                                                 rcwsclrpl.  */
8996                                                              return 3238;
8997                                                            }
8998                                                          else
8999                                                            {
9000                                                              /* 33222222222211111111110000000000
9001                                                                 10987654321098765432109876543210
9002                                                                 01011001011xxxxxxx1100xxxxxxxxxx
9003                                                                 rcwssetpl.  */
9004                                                              return 3254;
9005                                                            }
9006                                                        }
9007                                                    }
9008                                                  else
9009                                                    {
9010                                                      /* 33222222222211111111110000000000
9011                                                         10987654321098765432109876543210
9012                                                         11011001011xxxxxxxxx00xxxxxxxxxx
9013                                                         ldg.  */
9014                                                      return 934;
9015                                                    }
9016                                                }
9017                                            }
9018                                        }
9019                                      else
9020                                        {
9021                                          if (((word >> 21) & 0x1) == 0)
9022                                            {
9023                                              /* 33222222222211111111110000000000
9024                                                 10987654321098765432109876543210
9025                                                 xx011001010xxxxxxxxx10xxxxxxxxxx
9026                                                 ldiapp.  */
9027                                              return 1198;
9028                                            }
9029                                          else
9030                                            {
9031                                              if (((word >> 30) & 0x1) == 0)
9032                                                {
9033                                                  /* 33222222222211111111110000000000
9034                                                     10987654321098765432109876543210
9035                                                     x0011001011xxxxxxxxx10xxxxxxxxxx
9036                                                     rcwcasl.  */
9037                                                  return 3210;
9038                                                }
9039                                              else
9040                                                {
9041                                                  if (((word >> 31) & 0x1) == 0)
9042                                                    {
9043                                                      /* 33222222222211111111110000000000
9044                                                         10987654321098765432109876543210
9045                                                         01011001011xxxxxxxxx10xxxxxxxxxx
9046                                                         rcwscasl.  */
9047                                                      return 3218;
9048                                                    }
9049                                                  else
9050                                                    {
9051                                                      /* 33222222222211111111110000000000
9052                                                         10987654321098765432109876543210
9053                                                         11011001011xxxxxxxxx10xxxxxxxxxx
9054                                                         stzg.  */
9055                                                      return 882;
9056                                                    }
9057                                                }
9058                                            }
9059                                        }
9060                                    }
9061                                  else
9062                                    {
9063                                      if (((word >> 21) & 0x1) == 0)
9064                                        {
9065                                          if (((word >> 12) & 0x1) == 0)
9066                                            {
9067                                              if (((word >> 13) & 0x1) == 0)
9068                                                {
9069                                                  if (((word >> 14) & 0x1) == 0)
9070                                                    {
9071                                                      if (((word >> 15) & 0x1) == 0)
9072                                                        {
9073                                                          /* 33222222222211111111110000000000
9074                                                             10987654321098765432109876543210
9075                                                             xx011001010xxxxx0000x1xxxxxxxxxx
9076                                                             cpyfm.  */
9077                                                          return 3074;
9078                                                        }
9079                                                      else
9080                                                        {
9081                                                          /* 33222222222211111111110000000000
9082                                                             10987654321098765432109876543210
9083                                                             xx011001010xxxxx1000x1xxxxxxxxxx
9084                                                             cpyfmrn.  */
9085                                                          return 3080;
9086                                                        }
9087                                                    }
9088                                                  else
9089                                                    {
9090                                                      if (((word >> 15) & 0x1) == 0)
9091                                                        {
9092                                                          /* 33222222222211111111110000000000
9093                                                             10987654321098765432109876543210
9094                                                             xx011001010xxxxx0100x1xxxxxxxxxx
9095                                                             cpyfmwn.  */
9096                                                          return 3077;
9097                                                        }
9098                                                      else
9099                                                        {
9100                                                          /* 33222222222211111111110000000000
9101                                                             10987654321098765432109876543210
9102                                                             xx011001010xxxxx1100x1xxxxxxxxxx
9103                                                             cpyfmn.  */
9104                                                          return 3083;
9105                                                        }
9106                                                    }
9107                                                }
9108                                              else
9109                                                {
9110                                                  if (((word >> 14) & 0x1) == 0)
9111                                                    {
9112                                                      if (((word >> 15) & 0x1) == 0)
9113                                                        {
9114                                                          /* 33222222222211111111110000000000
9115                                                             10987654321098765432109876543210
9116                                                             xx011001010xxxxx0010x1xxxxxxxxxx
9117                                                             cpyfmrt.  */
9118                                                          return 3098;
9119                                                        }
9120                                                      else
9121                                                        {
9122                                                          /* 33222222222211111111110000000000
9123                                                             10987654321098765432109876543210
9124                                                             xx011001010xxxxx1010x1xxxxxxxxxx
9125                                                             cpyfmrtrn.  */
9126                                                          return 3104;
9127                                                        }
9128                                                    }
9129                                                  else
9130                                                    {
9131                                                      if (((word >> 15) & 0x1) == 0)
9132                                                        {
9133                                                          /* 33222222222211111111110000000000
9134                                                             10987654321098765432109876543210
9135                                                             xx011001010xxxxx0110x1xxxxxxxxxx
9136                                                             cpyfmrtwn.  */
9137                                                          return 3101;
9138                                                        }
9139                                                      else
9140                                                        {
9141                                                          /* 33222222222211111111110000000000
9142                                                             10987654321098765432109876543210
9143                                                             xx011001010xxxxx1110x1xxxxxxxxxx
9144                                                             cpyfmrtn.  */
9145                                                          return 3107;
9146                                                        }
9147                                                    }
9148                                                }
9149                                            }
9150                                          else
9151                                            {
9152                                              if (((word >> 13) & 0x1) == 0)
9153                                                {
9154                                                  if (((word >> 14) & 0x1) == 0)
9155                                                    {
9156                                                      if (((word >> 15) & 0x1) == 0)
9157                                                        {
9158                                                          /* 33222222222211111111110000000000
9159                                                             10987654321098765432109876543210
9160                                                             xx011001010xxxxx0001x1xxxxxxxxxx
9161                                                             cpyfmwt.  */
9162                                                          return 3086;
9163                                                        }
9164                                                      else
9165                                                        {
9166                                                          /* 33222222222211111111110000000000
9167                                                             10987654321098765432109876543210
9168                                                             xx011001010xxxxx1001x1xxxxxxxxxx
9169                                                             cpyfmwtrn.  */
9170                                                          return 3092;
9171                                                        }
9172                                                    }
9173                                                  else
9174                                                    {
9175                                                      if (((word >> 15) & 0x1) == 0)
9176                                                        {
9177                                                          /* 33222222222211111111110000000000
9178                                                             10987654321098765432109876543210
9179                                                             xx011001010xxxxx0101x1xxxxxxxxxx
9180                                                             cpyfmwtwn.  */
9181                                                          return 3089;
9182                                                        }
9183                                                      else
9184                                                        {
9185                                                          /* 33222222222211111111110000000000
9186                                                             10987654321098765432109876543210
9187                                                             xx011001010xxxxx1101x1xxxxxxxxxx
9188                                                             cpyfmwtn.  */
9189                                                          return 3095;
9190                                                        }
9191                                                    }
9192                                                }
9193                                              else
9194                                                {
9195                                                  if (((word >> 14) & 0x1) == 0)
9196                                                    {
9197                                                      if (((word >> 15) & 0x1) == 0)
9198                                                        {
9199                                                          /* 33222222222211111111110000000000
9200                                                             10987654321098765432109876543210
9201                                                             xx011001010xxxxx0011x1xxxxxxxxxx
9202                                                             cpyfmt.  */
9203                                                          return 3110;
9204                                                        }
9205                                                      else
9206                                                        {
9207                                                          /* 33222222222211111111110000000000
9208                                                             10987654321098765432109876543210
9209                                                             xx011001010xxxxx1011x1xxxxxxxxxx
9210                                                             cpyfmtrn.  */
9211                                                          return 3116;
9212                                                        }
9213                                                    }
9214                                                  else
9215                                                    {
9216                                                      if (((word >> 15) & 0x1) == 0)
9217                                                        {
9218                                                          /* 33222222222211111111110000000000
9219                                                             10987654321098765432109876543210
9220                                                             xx011001010xxxxx0111x1xxxxxxxxxx
9221                                                             cpyfmtwn.  */
9222                                                          return 3113;
9223                                                        }
9224                                                      else
9225                                                        {
9226                                                          /* 33222222222211111111110000000000
9227                                                             10987654321098765432109876543210
9228                                                             xx011001010xxxxx1111x1xxxxxxxxxx
9229                                                             cpyfmtn.  */
9230                                                          return 3119;
9231                                                        }
9232                                                    }
9233                                                }
9234                                            }
9235                                        }
9236                                      else
9237                                        {
9238                                          if (((word >> 30) & 0x1) == 0)
9239                                            {
9240                                              /* 33222222222211111111110000000000
9241                                                 10987654321098765432109876543210
9242                                                 x0011001011xxxxxxxxxx1xxxxxxxxxx
9243                                                 rcwcaspl.  */
9244                                              return 3214;
9245                                            }
9246                                          else
9247                                            {
9248                                              if (((word >> 31) & 0x1) == 0)
9249                                                {
9250                                                  /* 33222222222211111111110000000000
9251                                                     10987654321098765432109876543210
9252                                                     01011001011xxxxxxxxxx1xxxxxxxxxx
9253                                                     rcwscaspl.  */
9254                                                  return 3222;
9255                                                }
9256                                              else
9257                                                {
9258                                                  /* 33222222222211111111110000000000
9259                                                     10987654321098765432109876543210
9260                                                     11011001011xxxxxxxxxx1xxxxxxxxxx
9261                                                     stzg.  */
9262                                                  return 886;
9263                                                }
9264                                            }
9265                                        }
9266                                    }
9267                                }
9268                              else
9269                                {
9270                                  if (((word >> 31) & 0x1) == 0)
9271                                    {
9272                                      if (((word >> 30) & 0x1) == 0)
9273                                        {
9274                                          /* 33222222222211111111110000000000
9275                                             10987654321098765432109876543210
9276                                             0011100101xxxxxxxxxxxxxxxxxxxxxx
9277                                             ldrb.  */
9278                                          return 890;
9279                                        }
9280                                      else
9281                                        {
9282                                          /* 33222222222211111111110000000000
9283                                             10987654321098765432109876543210
9284                                             0111100101xxxxxxxxxxxxxxxxxxxxxx
9285                                             ldrh.  */
9286                                          return 895;
9287                                        }
9288                                    }
9289                                  else
9290                                    {
9291                                      /* 33222222222211111111110000000000
9292                                         10987654321098765432109876543210
9293                                         1x11100101xxxxxxxxxxxxxxxxxxxxxx
9294                                         ldr.  */
9295                                      return 898;
9296                                    }
9297                                }
9298                            }
9299                        }
9300                      else
9301                        {
9302                          if (((word >> 29) & 0x1) == 0)
9303                            {
9304                              if (((word >> 10) & 0x1) == 0)
9305                                {
9306                                  if (((word >> 11) & 0x1) == 0)
9307                                    {
9308                                      if (((word >> 21) & 0x1) == 0)
9309                                        {
9310                                          if (((word >> 22) & 0x1) == 0)
9311                                            {
9312                                              if (((word >> 30) & 0x1) == 0)
9313                                                {
9314                                                  if (((word >> 31) & 0x1) == 0)
9315                                                    {
9316                                                      /* 33222222222211111111110000000000
9317                                                         10987654321098765432109876543210
9318                                                         00011001100xxxxxxxxx00xxxxxxxxxx
9319                                                         ldapursb.  */
9320                                                      return 3016;
9321                                                    }
9322                                                  else
9323                                                    {
9324                                                      /* 33222222222211111111110000000000
9325                                                         10987654321098765432109876543210
9326                                                         10011001100xxxxxxxxx00xxxxxxxxxx
9327                                                         ldapursw.  */
9328                                                      return 3023;
9329                                                    }
9330                                                }
9331                                              else
9332                                                {
9333                                                  /* 33222222222211111111110000000000
9334                                                     10987654321098765432109876543210
9335                                                     x1011001100xxxxxxxxx00xxxxxxxxxx
9336                                                     ldapursh.  */
9337                                                  return 3020;
9338                                                }
9339                                            }
9340                                          else
9341                                            {
9342                                              if (((word >> 30) & 0x1) == 0)
9343                                                {
9344                                                  /* 33222222222211111111110000000000
9345                                                     10987654321098765432109876543210
9346                                                     x0011001110xxxxxxxxx00xxxxxxxxxx
9347                                                     ldapursb.  */
9348                                                  return 3015;
9349                                                }
9350                                              else
9351                                                {
9352                                                  /* 33222222222211111111110000000000
9353                                                     10987654321098765432109876543210
9354                                                     x1011001110xxxxxxxxx00xxxxxxxxxx
9355                                                     ldapursh.  */
9356                                                  return 3019;
9357                                                }
9358                                            }
9359                                        }
9360                                      else
9361                                        {
9362                                          if (((word >> 12) & 0x1) == 0)
9363                                            {
9364                                              if (((word >> 13) & 0x1) == 0)
9365                                                {
9366                                                  if (((word >> 15) & 0x1) == 0)
9367                                                    {
9368                                                      if (((word >> 22) & 0x1) == 0)
9369                                                        {
9370                                                          /* 33222222222211111111110000000000
9371                                                             10987654321098765432109876543210
9372                                                             xx011001101xxxxx0x0000xxxxxxxxxx
9373                                                             stgm.  */
9374                                                          return 963;
9375                                                        }
9376                                                      else
9377                                                        {
9378                                                          /* 33222222222211111111110000000000
9379                                                             10987654321098765432109876543210
9380                                                             xx011001111xxxxx0x0000xxxxxxxxxx
9381                                                             ldgm.  */
9382                                                          return 962;
9383                                                        }
9384                                                    }
9385                                                  else
9386                                                    {
9387                                                      if (((word >> 22) & 0x1) == 0)
9388                                                        {
9389                                                          /* 33222222222211111111110000000000
9390                                                             10987654321098765432109876543210
9391                                                             xx011001101xxxxx1x0000xxxxxxxxxx
9392                                                             swppa.  */
9393                                                          return 1195;
9394                                                        }
9395                                                      else
9396                                                        {
9397                                                          /* 33222222222211111111110000000000
9398                                                             10987654321098765432109876543210
9399                                                             xx011001111xxxxx1x0000xxxxxxxxxx
9400                                                             swppal.  */
9401                                                          return 1196;
9402                                                        }
9403                                                    }
9404                                                }
9405                                              else
9406                                                {
9407                                                  if (((word >> 22) & 0x1) == 0)
9408                                                    {
9409                                                      if (((word >> 30) & 0x1) == 0)
9410                                                        {
9411                                                          /* 33222222222211111111110000000000
9412                                                             10987654321098765432109876543210
9413                                                             x0011001101xxxxxxx1000xxxxxxxxxx
9414                                                             rcwswppa.  */
9415                                                          return 3260;
9416                                                        }
9417                                                      else
9418                                                        {
9419                                                          /* 33222222222211111111110000000000
9420                                                             10987654321098765432109876543210
9421                                                             x1011001101xxxxxxx1000xxxxxxxxxx
9422                                                             rcwsswppa.  */
9423                                                          return 3268;
9424                                                        }
9425                                                    }
9426                                                  else
9427                                                    {
9428                                                      if (((word >> 30) & 0x1) == 0)
9429                                                        {
9430                                                          /* 33222222222211111111110000000000
9431                                                             10987654321098765432109876543210
9432                                                             x0011001111xxxxxxx1000xxxxxxxxxx
9433                                                             rcwswppal.  */
9434                                                          return 3261;
9435                                                        }
9436                                                      else
9437                                                        {
9438                                                          /* 33222222222211111111110000000000
9439                                                             10987654321098765432109876543210
9440                                                             x1011001111xxxxxxx1000xxxxxxxxxx
9441                                                             rcwsswppal.  */
9442                                                          return 3269;
9443                                                        }
9444                                                    }
9445                                                }
9446                                            }
9447                                          else
9448                                            {
9449                                              if (((word >> 13) & 0x1) == 0)
9450                                                {
9451                                                  if (((word >> 15) & 0x1) == 0)
9452                                                    {
9453                                                      if (((word >> 22) & 0x1) == 0)
9454                                                        {
9455                                                          /* 33222222222211111111110000000000
9456                                                             10987654321098765432109876543210
9457                                                             xx011001101xxxxx0x0100xxxxxxxxxx
9458                                                             ldclrpa.  */
9459                                                          return 1187;
9460                                                        }
9461                                                      else
9462                                                        {
9463                                                          /* 33222222222211111111110000000000
9464                                                             10987654321098765432109876543210
9465                                                             xx011001111xxxxx0x0100xxxxxxxxxx
9466                                                             ldclrpal.  */
9467                                                          return 1188;
9468                                                        }
9469                                                    }
9470                                                  else
9471                                                    {
9472                                                      if (((word >> 22) & 0x1) == 0)
9473                                                        {
9474                                                          if (((word >> 30) & 0x1) == 0)
9475                                                            {
9476                                                              /* 33222222222211111111110000000000
9477                                                                 10987654321098765432109876543210
9478                                                                 x0011001101xxxxx1x0100xxxxxxxxxx
9479                                                                 rcwclrpa.  */
9480                                                              return 3228;
9481                                                            }
9482                                                          else
9483                                                            {
9484                                                              /* 33222222222211111111110000000000
9485                                                                 10987654321098765432109876543210
9486                                                                 x1011001101xxxxx1x0100xxxxxxxxxx
9487                                                                 rcwsclrpa.  */
9488                                                              return 3236;
9489                                                            }
9490                                                        }
9491                                                      else
9492                                                        {
9493                                                          if (((word >> 30) & 0x1) == 0)
9494                                                            {
9495                                                              /* 33222222222211111111110000000000
9496                                                                 10987654321098765432109876543210
9497                                                                 x0011001111xxxxx1x0100xxxxxxxxxx
9498                                                                 rcwclrpal.  */
9499                                                              return 3229;
9500                                                            }
9501                                                          else
9502                                                            {
9503                                                              /* 33222222222211111111110000000000
9504                                                                 10987654321098765432109876543210
9505                                                                 x1011001111xxxxx1x0100xxxxxxxxxx
9506                                                                 rcwsclrpal.  */
9507                                                              return 3237;
9508                                                            }
9509                                                        }
9510                                                    }
9511                                                }
9512                                              else
9513                                                {
9514                                                  if (((word >> 15) & 0x1) == 0)
9515                                                    {
9516                                                      if (((word >> 22) & 0x1) == 0)
9517                                                        {
9518                                                          /* 33222222222211111111110000000000
9519                                                             10987654321098765432109876543210
9520                                                             xx011001101xxxxx0x1100xxxxxxxxxx
9521                                                             ldsetpa.  */
9522                                                          return 1191;
9523                                                        }
9524                                                      else
9525                                                        {
9526                                                          /* 33222222222211111111110000000000
9527                                                             10987654321098765432109876543210
9528                                                             xx011001111xxxxx0x1100xxxxxxxxxx
9529                                                             ldsetpal.  */
9530                                                          return 1192;
9531                                                        }
9532                                                    }
9533                                                  else
9534                                                    {
9535                                                      if (((word >> 22) & 0x1) == 0)
9536                                                        {
9537                                                          if (((word >> 30) & 0x1) == 0)
9538                                                            {
9539                                                              /* 33222222222211111111110000000000
9540                                                                 10987654321098765432109876543210
9541                                                                 x0011001101xxxxx1x1100xxxxxxxxxx
9542                                                                 rcwsetpa.  */
9543                                                              return 3244;
9544                                                            }
9545                                                          else
9546                                                            {
9547                                                              /* 33222222222211111111110000000000
9548                                                                 10987654321098765432109876543210
9549                                                                 x1011001101xxxxx1x1100xxxxxxxxxx
9550                                                                 rcwssetpa.  */
9551                                                              return 3252;
9552                                                            }
9553                                                        }
9554                                                      else
9555                                                        {
9556                                                          if (((word >> 30) & 0x1) == 0)
9557                                                            {
9558                                                              /* 33222222222211111111110000000000
9559                                                                 10987654321098765432109876543210
9560                                                                 x0011001111xxxxx1x1100xxxxxxxxxx
9561                                                                 rcwsetpal.  */
9562                                                              return 3245;
9563                                                            }
9564                                                          else
9565                                                            {
9566                                                              /* 33222222222211111111110000000000
9567                                                                 10987654321098765432109876543210
9568                                                                 x1011001111xxxxx1x1100xxxxxxxxxx
9569                                                                 rcwssetpal.  */
9570                                                              return 3253;
9571                                                            }
9572                                                        }
9573                                                    }
9574                                                }
9575                                            }
9576                                        }
9577                                    }
9578                                  else
9579                                    {
9580                                      if (((word >> 21) & 0x1) == 0)
9581                                        {
9582                                          if (((word >> 22) & 0x1) == 0)
9583                                            {
9584                                              /* 33222222222211111111110000000000
9585                                                 10987654321098765432109876543210
9586                                                 xx011001100xxxxxxxxx10xxxxxxxxxx
9587                                                 stlr.  */
9588                                              return 1201;
9589                                            }
9590                                          else
9591                                            {
9592                                              /* 33222222222211111111110000000000
9593                                                 10987654321098765432109876543210
9594                                                 xx011001110xxxxxxxxx10xxxxxxxxxx
9595                                                 ldapr.  */
9596                                              return 1200;
9597                                            }
9598                                        }
9599                                      else
9600                                        {
9601                                          if (((word >> 22) & 0x1) == 0)
9602                                            {
9603                                              if (((word >> 30) & 0x1) == 0)
9604                                                {
9605                                                  /* 33222222222211111111110000000000
9606                                                     10987654321098765432109876543210
9607                                                     x0011001101xxxxxxxxx10xxxxxxxxxx
9608                                                     rcwcasa.  */
9609                                                  return 3208;
9610                                                }
9611                                              else
9612                                                {
9613                                                  if (((word >> 31) & 0x1) == 0)
9614                                                    {
9615                                                      /* 33222222222211111111110000000000
9616                                                         10987654321098765432109876543210
9617                                                         01011001101xxxxxxxxx10xxxxxxxxxx
9618                                                         rcwscasa.  */
9619                                                      return 3216;
9620                                                    }
9621                                                  else
9622                                                    {
9623                                                      /* 33222222222211111111110000000000
9624                                                         10987654321098765432109876543210
9625                                                         11011001101xxxxxxxxx10xxxxxxxxxx
9626                                                         st2g.  */
9627                                                      return 883;
9628                                                    }
9629                                                }
9630                                            }
9631                                          else
9632                                            {
9633                                              if (((word >> 30) & 0x1) == 0)
9634                                                {
9635                                                  /* 33222222222211111111110000000000
9636                                                     10987654321098765432109876543210
9637                                                     x0011001111xxxxxxxxx10xxxxxxxxxx
9638                                                     rcwcasal.  */
9639                                                  return 3209;
9640                                                }
9641                                              else
9642                                                {
9643                                                  if (((word >> 31) & 0x1) == 0)
9644                                                    {
9645                                                      /* 33222222222211111111110000000000
9646                                                         10987654321098765432109876543210
9647                                                         01011001111xxxxxxxxx10xxxxxxxxxx
9648                                                         rcwscasal.  */
9649                                                      return 3217;
9650                                                    }
9651                                                  else
9652                                                    {
9653                                                      /* 33222222222211111111110000000000
9654                                                         10987654321098765432109876543210
9655                                                         11011001111xxxxxxxxx10xxxxxxxxxx
9656                                                         stz2g.  */
9657                                                      return 884;
9658                                                    }
9659                                                }
9660                                            }
9661                                        }
9662                                    }
9663                                }
9664                              else
9665                                {
9666                                  if (((word >> 21) & 0x1) == 0)
9667                                    {
9668                                      if (((word >> 12) & 0x1) == 0)
9669                                        {
9670                                          if (((word >> 13) & 0x1) == 0)
9671                                            {
9672                                              if (((word >> 14) & 0x1) == 0)
9673                                                {
9674                                                  if (((word >> 15) & 0x1) == 0)
9675                                                    {
9676                                                      if (((word >> 22) & 0x1) == 0)
9677                                                        {
9678                                                          /* 33222222222211111111110000000000
9679                                                             10987654321098765432109876543210
9680                                                             xx011001100xxxxx0000x1xxxxxxxxxx
9681                                                             cpyfe.  */
9682                                                          return 3075;
9683                                                        }
9684                                                      else
9685                                                        {
9686                                                          /* 33222222222211111111110000000000
9687                                                             10987654321098765432109876543210
9688                                                             xx011001110xxxxx0000x1xxxxxxxxxx
9689                                                             setp.  */
9690                                                          return 3169;
9691                                                        }
9692                                                    }
9693                                                  else
9694                                                    {
9695                                                      if (((word >> 22) & 0x1) == 0)
9696                                                        {
9697                                                          /* 33222222222211111111110000000000
9698                                                             10987654321098765432109876543210
9699                                                             xx011001100xxxxx1000x1xxxxxxxxxx
9700                                                             cpyfern.  */
9701                                                          return 3081;
9702                                                        }
9703                                                      else
9704                                                        {
9705                                                          /* 33222222222211111111110000000000
9706                                                             10987654321098765432109876543210
9707                                                             xx011001110xxxxx1000x1xxxxxxxxxx
9708                                                             sete.  */
9709                                                          return 3171;
9710                                                        }
9711                                                    }
9712                                                }
9713                                              else
9714                                                {
9715                                                  if (((word >> 15) & 0x1) == 0)
9716                                                    {
9717                                                      if (((word >> 22) & 0x1) == 0)
9718                                                        {
9719                                                          /* 33222222222211111111110000000000
9720                                                             10987654321098765432109876543210
9721                                                             xx011001100xxxxx0100x1xxxxxxxxxx
9722                                                             cpyfewn.  */
9723                                                          return 3078;
9724                                                        }
9725                                                      else
9726                                                        {
9727                                                          /* 33222222222211111111110000000000
9728                                                             10987654321098765432109876543210
9729                                                             xx011001110xxxxx0100x1xxxxxxxxxx
9730                                                             setm.  */
9731                                                          return 3170;
9732                                                        }
9733                                                    }
9734                                                  else
9735                                                    {
9736                                                      /* 33222222222211111111110000000000
9737                                                         10987654321098765432109876543210
9738                                                         xx0110011x0xxxxx1100x1xxxxxxxxxx
9739                                                         cpyfen.  */
9740                                                      return 3084;
9741                                                    }
9742                                                }
9743                                            }
9744                                          else
9745                                            {
9746                                              if (((word >> 14) & 0x1) == 0)
9747                                                {
9748                                                  if (((word >> 15) & 0x1) == 0)
9749                                                    {
9750                                                      if (((word >> 22) & 0x1) == 0)
9751                                                        {
9752                                                          /* 33222222222211111111110000000000
9753                                                             10987654321098765432109876543210
9754                                                             xx011001100xxxxx0010x1xxxxxxxxxx
9755                                                             cpyfert.  */
9756                                                          return 3099;
9757                                                        }
9758                                                      else
9759                                                        {
9760                                                          /* 33222222222211111111110000000000
9761                                                             10987654321098765432109876543210
9762                                                             xx011001110xxxxx0010x1xxxxxxxxxx
9763                                                             setpn.  */
9764                                                          return 3175;
9765                                                        }
9766                                                    }
9767                                                  else
9768                                                    {
9769                                                      if (((word >> 22) & 0x1) == 0)
9770                                                        {
9771                                                          /* 33222222222211111111110000000000
9772                                                             10987654321098765432109876543210
9773                                                             xx011001100xxxxx1010x1xxxxxxxxxx
9774                                                             cpyfertrn.  */
9775                                                          return 3105;
9776                                                        }
9777                                                      else
9778                                                        {
9779                                                          /* 33222222222211111111110000000000
9780                                                             10987654321098765432109876543210
9781                                                             xx011001110xxxxx1010x1xxxxxxxxxx
9782                                                             seten.  */
9783                                                          return 3177;
9784                                                        }
9785                                                    }
9786                                                }
9787                                              else
9788                                                {
9789                                                  if (((word >> 15) & 0x1) == 0)
9790                                                    {
9791                                                      if (((word >> 22) & 0x1) == 0)
9792                                                        {
9793                                                          /* 33222222222211111111110000000000
9794                                                             10987654321098765432109876543210
9795                                                             xx011001100xxxxx0110x1xxxxxxxxxx
9796                                                             cpyfertwn.  */
9797                                                          return 3102;
9798                                                        }
9799                                                      else
9800                                                        {
9801                                                          /* 33222222222211111111110000000000
9802                                                             10987654321098765432109876543210
9803                                                             xx011001110xxxxx0110x1xxxxxxxxxx
9804                                                             setmn.  */
9805                                                          return 3176;
9806                                                        }
9807                                                    }
9808                                                  else
9809                                                    {
9810                                                      /* 33222222222211111111110000000000
9811                                                         10987654321098765432109876543210
9812                                                         xx0110011x0xxxxx1110x1xxxxxxxxxx
9813                                                         cpyfertn.  */
9814                                                      return 3108;
9815                                                    }
9816                                                }
9817                                            }
9818                                        }
9819                                      else
9820                                        {
9821                                          if (((word >> 13) & 0x1) == 0)
9822                                            {
9823                                              if (((word >> 14) & 0x1) == 0)
9824                                                {
9825                                                  if (((word >> 15) & 0x1) == 0)
9826                                                    {
9827                                                      if (((word >> 22) & 0x1) == 0)
9828                                                        {
9829                                                          /* 33222222222211111111110000000000
9830                                                             10987654321098765432109876543210
9831                                                             xx011001100xxxxx0001x1xxxxxxxxxx
9832                                                             cpyfewt.  */
9833                                                          return 3087;
9834                                                        }
9835                                                      else
9836                                                        {
9837                                                          /* 33222222222211111111110000000000
9838                                                             10987654321098765432109876543210
9839                                                             xx011001110xxxxx0001x1xxxxxxxxxx
9840                                                             setpt.  */
9841                                                          return 3172;
9842                                                        }
9843                                                    }
9844                                                  else
9845                                                    {
9846                                                      if (((word >> 22) & 0x1) == 0)
9847                                                        {
9848                                                          /* 33222222222211111111110000000000
9849                                                             10987654321098765432109876543210
9850                                                             xx011001100xxxxx1001x1xxxxxxxxxx
9851                                                             cpyfewtrn.  */
9852                                                          return 3093;
9853                                                        }
9854                                                      else
9855                                                        {
9856                                                          /* 33222222222211111111110000000000
9857                                                             10987654321098765432109876543210
9858                                                             xx011001110xxxxx1001x1xxxxxxxxxx
9859                                                             setet.  */
9860                                                          return 3174;
9861                                                        }
9862                                                    }
9863                                                }
9864                                              else
9865                                                {
9866                                                  if (((word >> 15) & 0x1) == 0)
9867                                                    {
9868                                                      if (((word >> 22) & 0x1) == 0)
9869                                                        {
9870                                                          /* 33222222222211111111110000000000
9871                                                             10987654321098765432109876543210
9872                                                             xx011001100xxxxx0101x1xxxxxxxxxx
9873                                                             cpyfewtwn.  */
9874                                                          return 3090;
9875                                                        }
9876                                                      else
9877                                                        {
9878                                                          /* 33222222222211111111110000000000
9879                                                             10987654321098765432109876543210
9880                                                             xx011001110xxxxx0101x1xxxxxxxxxx
9881                                                             setmt.  */
9882                                                          return 3173;
9883                                                        }
9884                                                    }
9885                                                  else
9886                                                    {
9887                                                      /* 33222222222211111111110000000000
9888                                                         10987654321098765432109876543210
9889                                                         xx0110011x0xxxxx1101x1xxxxxxxxxx
9890                                                         cpyfewtn.  */
9891                                                      return 3096;
9892                                                    }
9893                                                }
9894                                            }
9895                                          else
9896                                            {
9897                                              if (((word >> 14) & 0x1) == 0)
9898                                                {
9899                                                  if (((word >> 15) & 0x1) == 0)
9900                                                    {
9901                                                      if (((word >> 22) & 0x1) == 0)
9902                                                        {
9903                                                          /* 33222222222211111111110000000000
9904                                                             10987654321098765432109876543210
9905                                                             xx011001100xxxxx0011x1xxxxxxxxxx
9906                                                             cpyfet.  */
9907                                                          return 3111;
9908                                                        }
9909                                                      else
9910                                                        {
9911                                                          /* 33222222222211111111110000000000
9912                                                             10987654321098765432109876543210
9913                                                             xx011001110xxxxx0011x1xxxxxxxxxx
9914                                                             setptn.  */
9915                                                          return 3178;
9916                                                        }
9917                                                    }
9918                                                  else
9919                                                    {
9920                                                      if (((word >> 22) & 0x1) == 0)
9921                                                        {
9922                                                          /* 33222222222211111111110000000000
9923                                                             10987654321098765432109876543210
9924                                                             xx011001100xxxxx1011x1xxxxxxxxxx
9925                                                             cpyfetrn.  */
9926                                                          return 3117;
9927                                                        }
9928                                                      else
9929                                                        {
9930                                                          /* 33222222222211111111110000000000
9931                                                             10987654321098765432109876543210
9932                                                             xx011001110xxxxx1011x1xxxxxxxxxx
9933                                                             setetn.  */
9934                                                          return 3180;
9935                                                        }
9936                                                    }
9937                                                }
9938                                              else
9939                                                {
9940                                                  if (((word >> 15) & 0x1) == 0)
9941                                                    {
9942                                                      if (((word >> 22) & 0x1) == 0)
9943                                                        {
9944                                                          /* 33222222222211111111110000000000
9945                                                             10987654321098765432109876543210
9946                                                             xx011001100xxxxx0111x1xxxxxxxxxx
9947                                                             cpyfetwn.  */
9948                                                          return 3114;
9949                                                        }
9950                                                      else
9951                                                        {
9952                                                          /* 33222222222211111111110000000000
9953                                                             10987654321098765432109876543210
9954                                                             xx011001110xxxxx0111x1xxxxxxxxxx
9955                                                             setmtn.  */
9956                                                          return 3179;
9957                                                        }
9958                                                    }
9959                                                  else
9960                                                    {
9961                                                      /* 33222222222211111111110000000000
9962                                                         10987654321098765432109876543210
9963                                                         xx0110011x0xxxxx1111x1xxxxxxxxxx
9964                                                         cpyfetn.  */
9965                                                      return 3120;
9966                                                    }
9967                                                }
9968                                            }
9969                                        }
9970                                    }
9971                                  else
9972                                    {
9973                                      if (((word >> 22) & 0x1) == 0)
9974                                        {
9975                                          if (((word >> 30) & 0x1) == 0)
9976                                            {
9977                                              /* 33222222222211111111110000000000
9978                                                 10987654321098765432109876543210
9979                                                 x0011001101xxxxxxxxxx1xxxxxxxxxx
9980                                                 rcwcaspa.  */
9981                                              return 3212;
9982                                            }
9983                                          else
9984                                            {
9985                                              if (((word >> 31) & 0x1) == 0)
9986                                                {
9987                                                  /* 33222222222211111111110000000000
9988                                                     10987654321098765432109876543210
9989                                                     01011001101xxxxxxxxxx1xxxxxxxxxx
9990                                                     rcwscaspa.  */
9991                                                  return 3220;
9992                                                }
9993                                              else
9994                                                {
9995                                                  /* 33222222222211111111110000000000
9996                                                     10987654321098765432109876543210
9997                                                     11011001101xxxxxxxxxx1xxxxxxxxxx
9998                                                     st2g.  */
9999                                                  return 887;
10000                                                }
10001                                            }
10002                                        }
10003                                      else
10004                                        {
10005                                          if (((word >> 30) & 0x1) == 0)
10006                                            {
10007                                              /* 33222222222211111111110000000000
10008                                                 10987654321098765432109876543210
10009                                                 x0011001111xxxxxxxxxx1xxxxxxxxxx
10010                                                 rcwcaspal.  */
10011                                              return 3213;
10012                                            }
10013                                          else
10014                                            {
10015                                              if (((word >> 31) & 0x1) == 0)
10016                                                {
10017                                                  /* 33222222222211111111110000000000
10018                                                     10987654321098765432109876543210
10019                                                     01011001111xxxxxxxxxx1xxxxxxxxxx
10020                                                     rcwscaspal.  */
10021                                                  return 3221;
10022                                                }
10023                                              else
10024                                                {
10025                                                  /* 33222222222211111111110000000000
10026                                                     10987654321098765432109876543210
10027                                                     11011001111xxxxxxxxxx1xxxxxxxxxx
10028                                                     stz2g.  */
10029                                                  return 888;
10030                                                }
10031                                            }
10032                                        }
10033                                    }
10034                                }
10035                            }
10036                          else
10037                            {
10038                              if (((word >> 30) & 0x1) == 0)
10039                                {
10040                                  if (((word >> 31) & 0x1) == 0)
10041                                    {
10042                                      /* 33222222222211111111110000000000
10043                                         10987654321098765432109876543210
10044                                         001110011xxxxxxxxxxxxxxxxxxxxxxx
10045                                         ldrsb.  */
10046                                      return 891;
10047                                    }
10048                                  else
10049                                    {
10050                                      /* 33222222222211111111110000000000
10051                                         10987654321098765432109876543210
10052                                         101110011xxxxxxxxxxxxxxxxxxxxxxx
10053                                         ldrsw.  */
10054                                      return 899;
10055                                    }
10056                                }
10057                              else
10058                                {
10059                                  if (((word >> 31) & 0x1) == 0)
10060                                    {
10061                                      /* 33222222222211111111110000000000
10062                                         10987654321098765432109876543210
10063                                         011110011xxxxxxxxxxxxxxxxxxxxxxx
10064                                         ldrsh.  */
10065                                      return 896;
10066                                    }
10067                                  else
10068                                    {
10069                                      /* 33222222222211111111110000000000
10070                                         10987654321098765432109876543210
10071                                         111110011xxxxxxxxxxxxxxxxxxxxxxx
10072                                         prfm.  */
10073                                      return 900;
10074                                    }
10075                                }
10076                            }
10077                        }
10078                    }
10079                }
10080            }
10081        }
10082      else
10083        {
10084          if (((word >> 24) & 0x1) == 0)
10085            {
10086              if (((word >> 27) & 0x1) == 0)
10087                {
10088                  if (((word >> 23) & 0x1) == 0)
10089                    {
10090                      if (((word >> 29) & 0x1) == 0)
10091                        {
10092                          if (((word >> 30) & 0x1) == 0)
10093                            {
10094                              /* 33222222222211111111110000000000
10095                                 10987654321098765432109876543210
10096                                 x00x00100xxxxxxxxxxxxxxxxxxxxxxx
10097                                 and.  */
10098                              return 995;
10099                            }
10100                          else
10101                            {
10102                              /* 33222222222211111111110000000000
10103                                 10987654321098765432109876543210
10104                                 x10x00100xxxxxxxxxxxxxxxxxxxxxxx
10105                                 eor.  */
10106                              return 999;
10107                            }
10108                        }
10109                      else
10110                        {
10111                          if (((word >> 30) & 0x1) == 0)
10112                            {
10113                              /* 33222222222211111111110000000000
10114                                 10987654321098765432109876543210
10115                                 x01x00100xxxxxxxxxxxxxxxxxxxxxxx
10116                                 orr.  */
10117                              return 997;
10118                            }
10119                          else
10120                            {
10121                              /* 33222222222211111111110000000000
10122                                 10987654321098765432109876543210
10123                                 x11x00100xxxxxxxxxxxxxxxxxxxxxxx
10124                                 ands.  */
10125                              return 1000;
10126                            }
10127                        }
10128                    }
10129                  else
10130                    {
10131                      if (((word >> 29) & 0x1) == 0)
10132                        {
10133                          if (((word >> 30) & 0x1) == 0)
10134                            {
10135                              /* 33222222222211111111110000000000
10136                                 10987654321098765432109876543210
10137                                 x00x00101xxxxxxxxxxxxxxxxxxxxxxx
10138                                 movn.  */
10139                              return 1206;
10140                            }
10141                          else
10142                            {
10143                              /* 33222222222211111111110000000000
10144                                 10987654321098765432109876543210
10145                                 x10x00101xxxxxxxxxxxxxxxxxxxxxxx
10146                                 movz.  */
10147                              return 1208;
10148                            }
10149                        }
10150                      else
10151                        {
10152                          /* 33222222222211111111110000000000
10153                             10987654321098765432109876543210
10154                             xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
10155                             movk.  */
10156                          return 1210;
10157                        }
10158                    }
10159                }
10160              else
10161                {
10162                  if (((word >> 21) & 0x1) == 0)
10163                    {
10164                      if (((word >> 28) & 0x1) == 0)
10165                        {
10166                          if (((word >> 29) & 0x1) == 0)
10167                            {
10168                              if (((word >> 30) & 0x1) == 0)
10169                                {
10170                                  /* 33222222222211111111110000000000
10171                                     10987654321098765432109876543210
10172                                     x0001010xx0xxxxxxxxxxxxxxxxxxxxx
10173                                     and.  */
10174                                  return 1002;
10175                                }
10176                              else
10177                                {
10178                                  /* 33222222222211111111110000000000
10179                                     10987654321098765432109876543210
10180                                     x1001010xx0xxxxxxxxxxxxxxxxxxxxx
10181                                     eor.  */
10182                                  return 1009;
10183                                }
10184                            }
10185                          else
10186                            {
10187                              if (((word >> 30) & 0x1) == 0)
10188                                {
10189                                  /* 33222222222211111111110000000000
10190                                     10987654321098765432109876543210
10191                                     x0101010xx0xxxxxxxxxxxxxxxxxxxxx
10192                                     orr.  */
10193                                  return 1004;
10194                                }
10195                              else
10196                                {
10197                                  /* 33222222222211111111110000000000
10198                                     10987654321098765432109876543210
10199                                     x1101010xx0xxxxxxxxxxxxxxxxxxxxx
10200                                     ands.  */
10201                                  return 1011;
10202                                }
10203                            }
10204                        }
10205                      else
10206                        {
10207                          if (((word >> 10) & 0x1) == 0)
10208                            {
10209                              if (((word >> 11) & 0x1) == 0)
10210                                {
10211                                  if (((word >> 22) & 0x1) == 0)
10212                                    {
10213                                      if (((word >> 23) & 0x1) == 0)
10214                                        {
10215                                          if (((word >> 29) & 0x1) == 0)
10216                                            {
10217                                              if (((word >> 30) & 0x1) == 0)
10218                                                {
10219                                                  /* 33222222222211111111110000000000
10220                                                     10987654321098765432109876543210
10221                                                     x0011010000xxxxxxxxx00xxxxxxxxxx
10222                                                     adc.  */
10223                                                  return 0;
10224                                                }
10225                                              else
10226                                                {
10227                                                  /* 33222222222211111111110000000000
10228                                                     10987654321098765432109876543210
10229                                                     x1011010000xxxxxxxxx00xxxxxxxxxx
10230                                                     sbc.  */
10231                                                  return 2;
10232                                                }
10233                                            }
10234                                          else
10235                                            {
10236                                              if (((word >> 30) & 0x1) == 0)
10237                                                {
10238                                                  /* 33222222222211111111110000000000
10239                                                     10987654321098765432109876543210
10240                                                     x0111010000xxxxxxxxx00xxxxxxxxxx
10241                                                     adcs.  */
10242                                                  return 1;
10243                                                }
10244                                              else
10245                                                {
10246                                                  /* 33222222222211111111110000000000
10247                                                     10987654321098765432109876543210
10248                                                     x1111010000xxxxxxxxx00xxxxxxxxxx
10249                                                     sbcs.  */
10250                                                  return 4;
10251                                                }
10252                                            }
10253                                        }
10254                                      else
10255                                        {
10256                                          if (((word >> 30) & 0x1) == 0)
10257                                            {
10258                                              /* 33222222222211111111110000000000
10259                                                 10987654321098765432109876543210
10260                                                 x0x11010100xxxxxxxxx00xxxxxxxxxx
10261                                                 csel.  */
10262                                              return 662;
10263                                            }
10264                                          else
10265                                            {
10266                                              /* 33222222222211111111110000000000
10267                                                 10987654321098765432109876543210
10268                                                 x1x11010100xxxxxxxxx00xxxxxxxxxx
10269                                                 csinv.  */
10270                                              return 666;
10271                                            }
10272                                        }
10273                                    }
10274                                  else
10275                                    {
10276                                      if (((word >> 23) & 0x1) == 0)
10277                                        {
10278                                          if (((word >> 30) & 0x1) == 0)
10279                                            {
10280                                              /* 33222222222211111111110000000000
10281                                                 10987654321098765432109876543210
10282                                                 x0x11010010xxxxxxxxx00xxxxxxxxxx
10283                                                 ccmn.  */
10284                                              return 660;
10285                                            }
10286                                          else
10287                                            {
10288                                              /* 33222222222211111111110000000000
10289                                                 10987654321098765432109876543210
10290                                                 x1x11010010xxxxxxxxx00xxxxxxxxxx
10291                                                 ccmp.  */
10292                                              return 661;
10293                                            }
10294                                        }
10295                                      else
10296                                        {
10297                                          if (((word >> 12) & 0x1) == 0)
10298                                            {
10299                                              if (((word >> 13) & 0x1) == 0)
10300                                                {
10301                                                  if (((word >> 14) & 0x1) == 0)
10302                                                    {
10303                                                      if (((word >> 29) & 0x1) == 0)
10304                                                        {
10305                                                          if (((word >> 30) & 0x1) == 0)
10306                                                            {
10307                                                              /* 33222222222211111111110000000000
10308                                                                 10987654321098765432109876543210
10309                                                                 x0011010110xxxxxx00000xxxxxxxxxx
10310                                                                 subp.  */
10311                                                              return 721;
10312                                                            }
10313                                                          else
10314                                                            {
10315                                                              if (((word >> 16) & 0x1) == 0)
10316                                                                {
10317                                                                  /* 33222222222211111111110000000000
10318                                                                     10987654321098765432109876543210
10319                                                                     x1011010110xxxx0x00000xxxxxxxxxx
10320                                                                     rbit.  */
10321                                                                  return 685;
10322                                                                }
10323                                                              else
10324                                                                {
10325                                                                  /* 33222222222211111111110000000000
10326                                                                     10987654321098765432109876543210
10327                                                                     x1011010110xxxx1x00000xxxxxxxxxx
10328                                                                     pacia.  */
10329                                                                  return 693;
10330                                                                }
10331                                                            }
10332                                                        }
10333                                                      else
10334                                                        {
10335                                                          /* 33222222222211111111110000000000
10336                                                             10987654321098765432109876543210
10337                                                             xx111010110xxxxxx00000xxxxxxxxxx
10338                                                             subps.  */
10339                                                          return 722;
10340                                                        }
10341                                                    }
10342                                                  else
10343                                                    {
10344                                                      if (((word >> 30) & 0x1) == 0)
10345                                                        {
10346                                                          /* 33222222222211111111110000000000
10347                                                             10987654321098765432109876543210
10348                                                             x0x11010110xxxxxx10000xxxxxxxxxx
10349                                                             crc32b.  */
10350                                                          return 727;
10351                                                        }
10352                                                      else
10353                                                        {
10354                                                          /* 33222222222211111111110000000000
10355                                                             10987654321098765432109876543210
10356                                                             x1x11010110xxxxxx10000xxxxxxxxxx
10357                                                             xpaci.  */
10358                                                          return 709;
10359                                                        }
10360                                                    }
10361                                                }
10362                                              else
10363                                                {
10364                                                  if (((word >> 14) & 0x1) == 0)
10365                                                    {
10366                                                      if (((word >> 30) & 0x1) == 0)
10367                                                        {
10368                                                          /* 33222222222211111111110000000000
10369                                                             10987654321098765432109876543210
10370                                                             x0x11010110xxxxxx01000xxxxxxxxxx
10371                                                             lslv.  */
10372                                                          return 713;
10373                                                        }
10374                                                      else
10375                                                        {
10376                                                          if (((word >> 16) & 0x1) == 0)
10377                                                            {
10378                                                              /* 33222222222211111111110000000000
10379                                                                 10987654321098765432109876543210
10380                                                                 x1x11010110xxxx0x01000xxxxxxxxxx
10381                                                                 abs.  */
10382                                                              return 3198;
10383                                                            }
10384                                                          else
10385                                                            {
10386                                                              /* 33222222222211111111110000000000
10387                                                                 10987654321098765432109876543210
10388                                                                 x1x11010110xxxx1x01000xxxxxxxxxx
10389                                                                 paciza.  */
10390                                                              return 701;
10391                                                            }
10392                                                        }
10393                                                    }
10394                                                  else
10395                                                    {
10396                                                      /* 33222222222211111111110000000000
10397                                                         10987654321098765432109876543210
10398                                                         xxx11010110xxxxxx11000xxxxxxxxxx
10399                                                         smax.  */
10400                                                      return 3201;
10401                                                    }
10402                                                }
10403                                            }
10404                                          else
10405                                            {
10406                                              if (((word >> 13) & 0x1) == 0)
10407                                                {
10408                                                  if (((word >> 14) & 0x1) == 0)
10409                                                    {
10410                                                      if (((word >> 30) & 0x1) == 0)
10411                                                        {
10412                                                          /* 33222222222211111111110000000000
10413                                                             10987654321098765432109876543210
10414                                                             x0x11010110xxxxxx00100xxxxxxxxxx
10415                                                             irg.  */
10416                                                          return 724;
10417                                                        }
10418                                                      else
10419                                                        {
10420                                                          if (((word >> 16) & 0x1) == 0)
10421                                                            {
10422                                                              /* 33222222222211111111110000000000
10423                                                                 10987654321098765432109876543210
10424                                                                 x1x11010110xxxx0x00100xxxxxxxxxx
10425                                                                 clz.  */
10426                                                              return 690;
10427                                                            }
10428                                                          else
10429                                                            {
10430                                                              /* 33222222222211111111110000000000
10431                                                                 10987654321098765432109876543210
10432                                                                 x1x11010110xxxx1x00100xxxxxxxxxx
10433                                                                 autia.  */
10434                                                              return 697;
10435                                                            }
10436                                                        }
10437                                                    }
10438                                                  else
10439                                                    {
10440                                                      /* 33222222222211111111110000000000
10441                                                         10987654321098765432109876543210
10442                                                         xxx11010110xxxxxx10100xxxxxxxxxx
10443                                                         crc32cb.  */
10444                                                      return 731;
10445                                                    }
10446                                                }
10447                                              else
10448                                                {
10449                                                  if (((word >> 30) & 0x1) == 0)
10450                                                    {
10451                                                      /* 33222222222211111111110000000000
10452                                                         10987654321098765432109876543210
10453                                                         x0x11010110xxxxxxx1100xxxxxxxxxx
10454                                                         pacga.  */
10455                                                      return 726;
10456                                                    }
10457                                                  else
10458                                                    {
10459                                                      /* 33222222222211111111110000000000
10460                                                         10987654321098765432109876543210
10461                                                         x1x11010110xxxxxxx1100xxxxxxxxxx
10462                                                         autiza.  */
10463                                                      return 705;
10464                                                    }
10465                                                }
10466                                            }
10467                                        }
10468                                    }
10469                                }
10470                              else
10471                                {
10472                                  if (((word >> 22) & 0x1) == 0)
10473                                    {
10474                                      if (((word >> 14) & 0x1) == 0)
10475                                        {
10476                                          /* 33222222222211111111110000000000
10477                                             10987654321098765432109876543210
10478                                             xxx11010x00xxxxxx0xx10xxxxxxxxxx
10479                                             setf8.  */
10480                                          return 3011;
10481                                        }
10482                                      else
10483                                        {
10484                                          /* 33222222222211111111110000000000
10485                                             10987654321098765432109876543210
10486                                             xxx11010x00xxxxxx1xx10xxxxxxxxxx
10487                                             setf16.  */
10488                                          return 3012;
10489                                        }
10490                                    }
10491                                  else
10492                                    {
10493                                      if (((word >> 23) & 0x1) == 0)
10494                                        {
10495                                          if (((word >> 30) & 0x1) == 0)
10496                                            {
10497                                              /* 33222222222211111111110000000000
10498                                                 10987654321098765432109876543210
10499                                                 x0x11010010xxxxxxxxx10xxxxxxxxxx
10500                                                 ccmn.  */
10501                                              return 658;
10502                                            }
10503                                          else
10504                                            {
10505                                              /* 33222222222211111111110000000000
10506                                                 10987654321098765432109876543210
10507                                                 x1x11010010xxxxxxxxx10xxxxxxxxxx
10508                                                 ccmp.  */
10509                                              return 659;
10510                                            }
10511                                        }
10512                                      else
10513                                        {
10514                                          if (((word >> 12) & 0x1) == 0)
10515                                            {
10516                                              if (((word >> 13) & 0x1) == 0)
10517                                                {
10518                                                  if (((word >> 14) & 0x1) == 0)
10519                                                    {
10520                                                      if (((word >> 30) & 0x1) == 0)
10521                                                        {
10522                                                          /* 33222222222211111111110000000000
10523                                                             10987654321098765432109876543210
10524                                                             x0x11010110xxxxxx00010xxxxxxxxxx
10525                                                             udiv.  */
10526                                                          return 711;
10527                                                        }
10528                                                      else
10529                                                        {
10530                                                          if (((word >> 16) & 0x1) == 0)
10531                                                            {
10532                                                              if (((word >> 31) & 0x1) == 0)
10533                                                                {
10534                                                                  /* 33222222222211111111110000000000
10535                                                                     10987654321098765432109876543210
10536                                                                     01x11010110xxxx0x00010xxxxxxxxxx
10537                                                                     rev.  */
10538                                                                  return 687;
10539                                                                }
10540                                                              else
10541                                                                {
10542                                                                  /* 33222222222211111111110000000000
10543                                                                     10987654321098765432109876543210
10544                                                                     11x11010110xxxx0x00010xxxxxxxxxx
10545                                                                     rev32.  */
10546                                                                  return 692;
10547                                                                }
10548                                                            }
10549                                                          else
10550                                                            {
10551                                                              /* 33222222222211111111110000000000
10552                                                                 10987654321098765432109876543210
10553                                                                 x1x11010110xxxx1x00010xxxxxxxxxx
10554                                                                 pacda.  */
10555                                                              return 695;
10556                                                            }
10557                                                        }
10558                                                    }
10559                                                  else
10560                                                    {
10561                                                      /* 33222222222211111111110000000000
10562                                                         10987654321098765432109876543210
10563                                                         xxx11010110xxxxxx10010xxxxxxxxxx
10564                                                         crc32w.  */
10565                                                      return 729;
10566                                                    }
10567                                                }
10568                                              else
10569                                                {
10570                                                  if (((word >> 14) & 0x1) == 0)
10571                                                    {
10572                                                      if (((word >> 30) & 0x1) == 0)
10573                                                        {
10574                                                          /* 33222222222211111111110000000000
10575                                                             10987654321098765432109876543210
10576                                                             x0x11010110xxxxxx01010xxxxxxxxxx
10577                                                             asrv.  */
10578                                                          return 717;
10579                                                        }
10580                                                      else
10581                                                        {
10582                                                          /* 33222222222211111111110000000000
10583                                                             10987654321098765432109876543210
10584                                                             x1x11010110xxxxxx01010xxxxxxxxxx
10585                                                             pacdza.  */
10586                                                          return 703;
10587                                                        }
10588                                                    }
10589                                                  else
10590                                                    {
10591                                                      /* 33222222222211111111110000000000
10592                                                         10987654321098765432109876543210
10593                                                         xxx11010110xxxxxx11010xxxxxxxxxx
10594                                                         smin.  */
10595                                                      return 3203;
10596                                                    }
10597                                                }
10598                                            }
10599                                          else
10600                                            {
10601                                              if (((word >> 13) & 0x1) == 0)
10602                                                {
10603                                                  if (((word >> 14) & 0x1) == 0)
10604                                                    {
10605                                                      if (((word >> 16) & 0x1) == 0)
10606                                                        {
10607                                                          /* 33222222222211111111110000000000
10608                                                             10987654321098765432109876543210
10609                                                             xxx11010110xxxx0x00110xxxxxxxxxx
10610                                                             ctz.  */
10611                                                          return 3200;
10612                                                        }
10613                                                      else
10614                                                        {
10615                                                          /* 33222222222211111111110000000000
10616                                                             10987654321098765432109876543210
10617                                                             xxx11010110xxxx1x00110xxxxxxxxxx
10618                                                             autda.  */
10619                                                          return 699;
10620                                                        }
10621                                                    }
10622                                                  else
10623                                                    {
10624                                                      /* 33222222222211111111110000000000
10625                                                         10987654321098765432109876543210
10626                                                         xxx11010110xxxxxx10110xxxxxxxxxx
10627                                                         crc32cw.  */
10628                                                      return 733;
10629                                                    }
10630                                                }
10631                                              else
10632                                                {
10633                                                  /* 33222222222211111111110000000000
10634                                                     10987654321098765432109876543210
10635                                                     xxx11010110xxxxxxx1110xxxxxxxxxx
10636                                                     autdza.  */
10637                                                  return 707;
10638                                                }
10639                                            }
10640                                        }
10641                                    }
10642                                }
10643                            }
10644                          else
10645                            {
10646                              if (((word >> 11) & 0x1) == 0)
10647                                {
10648                                  if (((word >> 22) & 0x1) == 0)
10649                                    {
10650                                      if (((word >> 23) & 0x1) == 0)
10651                                        {
10652                                          /* 33222222222211111111110000000000
10653                                             10987654321098765432109876543210
10654                                             xxx11010000xxxxxxxxx01xxxxxxxxxx
10655                                             rmif.  */
10656                                          return 3010;
10657                                        }
10658                                      else
10659                                        {
10660                                          if (((word >> 30) & 0x1) == 0)
10661                                            {
10662                                              /* 33222222222211111111110000000000
10663                                                 10987654321098765432109876543210
10664                                                 x0x11010100xxxxxxxxx01xxxxxxxxxx
10665                                                 csinc.  */
10666                                              return 663;
10667                                            }
10668                                          else
10669                                            {
10670                                              /* 33222222222211111111110000000000
10671                                                 10987654321098765432109876543210
10672                                                 x1x11010100xxxxxxxxx01xxxxxxxxxx
10673                                                 csneg.  */
10674                                              return 669;
10675                                            }
10676                                        }
10677                                    }
10678                                  else
10679                                    {
10680                                      if (((word >> 12) & 0x1) == 0)
10681                                        {
10682                                          if (((word >> 13) & 0x1) == 0)
10683                                            {
10684                                              if (((word >> 14) & 0x1) == 0)
10685                                                {
10686                                                  if (((word >> 16) & 0x1) == 0)
10687                                                    {
10688                                                      /* 33222222222211111111110000000000
10689                                                         10987654321098765432109876543210
10690                                                         xxx11010x10xxxx0x00001xxxxxxxxxx
10691                                                         rev16.  */
10692                                                      return 686;
10693                                                    }
10694                                                  else
10695                                                    {
10696                                                      /* 33222222222211111111110000000000
10697                                                         10987654321098765432109876543210
10698                                                         xxx11010x10xxxx1x00001xxxxxxxxxx
10699                                                         pacib.  */
10700                                                      return 694;
10701                                                    }
10702                                                }
10703                                              else
10704                                                {
10705                                                  if (((word >> 30) & 0x1) == 0)
10706                                                    {
10707                                                      /* 33222222222211111111110000000000
10708                                                         10987654321098765432109876543210
10709                                                         x0x11010x10xxxxxx10001xxxxxxxxxx
10710                                                         crc32h.  */
10711                                                      return 728;
10712                                                    }
10713                                                  else
10714                                                    {
10715                                                      /* 33222222222211111111110000000000
10716                                                         10987654321098765432109876543210
10717                                                         x1x11010x10xxxxxx10001xxxxxxxxxx
10718                                                         xpacd.  */
10719                                                      return 710;
10720                                                    }
10721                                                }
10722                                            }
10723                                          else
10724                                            {
10725                                              if (((word >> 14) & 0x1) == 0)
10726                                                {
10727                                                  if (((word >> 30) & 0x1) == 0)
10728                                                    {
10729                                                      /* 33222222222211111111110000000000
10730                                                         10987654321098765432109876543210
10731                                                         x0x11010x10xxxxxx01001xxxxxxxxxx
10732                                                         lsrv.  */
10733                                                      return 715;
10734                                                    }
10735                                                  else
10736                                                    {
10737                                                      /* 33222222222211111111110000000000
10738                                                         10987654321098765432109876543210
10739                                                         x1x11010x10xxxxxx01001xxxxxxxxxx
10740                                                         pacizb.  */
10741                                                      return 702;
10742                                                    }
10743                                                }
10744                                              else
10745                                                {
10746                                                  /* 33222222222211111111110000000000
10747                                                     10987654321098765432109876543210
10748                                                     xxx11010x10xxxxxx11001xxxxxxxxxx
10749                                                     umax.  */
10750                                                  return 3202;
10751                                                }
10752                                            }
10753                                        }
10754                                      else
10755                                        {
10756                                          if (((word >> 13) & 0x1) == 0)
10757                                            {
10758                                              if (((word >> 14) & 0x1) == 0)
10759                                                {
10760                                                  if (((word >> 30) & 0x1) == 0)
10761                                                    {
10762                                                      /* 33222222222211111111110000000000
10763                                                         10987654321098765432109876543210
10764                                                         x0x11010x10xxxxxx00101xxxxxxxxxx
10765                                                         gmi.  */
10766                                                      return 725;
10767                                                    }
10768                                                  else
10769                                                    {
10770                                                      if (((word >> 16) & 0x1) == 0)
10771                                                        {
10772                                                          /* 33222222222211111111110000000000
10773                                                             10987654321098765432109876543210
10774                                                             x1x11010x10xxxx0x00101xxxxxxxxxx
10775                                                             cls.  */
10776                                                          return 691;
10777                                                        }
10778                                                      else
10779                                                        {
10780                                                          /* 33222222222211111111110000000000
10781                                                             10987654321098765432109876543210
10782                                                             x1x11010x10xxxx1x00101xxxxxxxxxx
10783                                                             autib.  */
10784                                                          return 698;
10785                                                        }
10786                                                    }
10787                                                }
10788                                              else
10789                                                {
10790                                                  /* 33222222222211111111110000000000
10791                                                     10987654321098765432109876543210
10792                                                     xxx11010x10xxxxxx10101xxxxxxxxxx
10793                                                     crc32ch.  */
10794                                                  return 732;
10795                                                }
10796                                            }
10797                                          else
10798                                            {
10799                                              /* 33222222222211111111110000000000
10800                                                 10987654321098765432109876543210
10801                                                 xxx11010x10xxxxxxx1101xxxxxxxxxx
10802                                                 autizb.  */
10803                                              return 706;
10804                                            }
10805                                        }
10806                                    }
10807                                }
10808                              else
10809                                {
10810                                  if (((word >> 12) & 0x1) == 0)
10811                                    {
10812                                      if (((word >> 13) & 0x1) == 0)
10813                                        {
10814                                          if (((word >> 14) & 0x1) == 0)
10815                                            {
10816                                              if (((word >> 30) & 0x1) == 0)
10817                                                {
10818                                                  /* 33222222222211111111110000000000
10819                                                     10987654321098765432109876543210
10820                                                     x0x11010xx0xxxxxx00011xxxxxxxxxx
10821                                                     sdiv.  */
10822                                                  return 712;
10823                                                }
10824                                              else
10825                                                {
10826                                                  if (((word >> 16) & 0x1) == 0)
10827                                                    {
10828                                                      /* 33222222222211111111110000000000
10829                                                         10987654321098765432109876543210
10830                                                         x1x11010xx0xxxx0x00011xxxxxxxxxx
10831                                                         rev.  */
10832                                                      return 688;
10833                                                    }
10834                                                  else
10835                                                    {
10836                                                      /* 33222222222211111111110000000000
10837                                                         10987654321098765432109876543210
10838                                                         x1x11010xx0xxxx1x00011xxxxxxxxxx
10839                                                         pacdb.  */
10840                                                      return 696;
10841                                                    }
10842                                                }
10843                                            }
10844                                          else
10845                                            {
10846                                              /* 33222222222211111111110000000000
10847                                                 10987654321098765432109876543210
10848                                                 xxx11010xx0xxxxxx10011xxxxxxxxxx
10849                                                 crc32x.  */
10850                                              return 730;
10851                                            }
10852                                        }
10853                                      else
10854                                        {
10855                                          if (((word >> 14) & 0x1) == 0)
10856                                            {
10857                                              if (((word >> 30) & 0x1) == 0)
10858                                                {
10859                                                  /* 33222222222211111111110000000000
10860                                                     10987654321098765432109876543210
10861                                                     x0x11010xx0xxxxxx01011xxxxxxxxxx
10862                                                     rorv.  */
10863                                                  return 719;
10864                                                }
10865                                              else
10866                                                {
10867                                                  /* 33222222222211111111110000000000
10868                                                     10987654321098765432109876543210
10869                                                     x1x11010xx0xxxxxx01011xxxxxxxxxx
10870                                                     pacdzb.  */
10871                                                  return 704;
10872                                                }
10873                                            }
10874                                          else
10875                                            {
10876                                              /* 33222222222211111111110000000000
10877                                                 10987654321098765432109876543210
10878                                                 xxx11010xx0xxxxxx11011xxxxxxxxxx
10879                                                 umin.  */
10880                                              return 3204;
10881                                            }
10882                                        }
10883                                    }
10884                                  else
10885                                    {
10886                                      if (((word >> 13) & 0x1) == 0)
10887                                        {
10888                                          if (((word >> 14) & 0x1) == 0)
10889                                            {
10890                                              if (((word >> 16) & 0x1) == 0)
10891                                                {
10892                                                  /* 33222222222211111111110000000000
10893                                                     10987654321098765432109876543210
10894                                                     xxx11010xx0xxxx0x00111xxxxxxxxxx
10895                                                     cnt.  */
10896                                                  return 3199;
10897                                                }
10898                                              else
10899                                                {
10900                                                  /* 33222222222211111111110000000000
10901                                                     10987654321098765432109876543210
10902                                                     xxx11010xx0xxxx1x00111xxxxxxxxxx
10903                                                     autdb.  */
10904                                                  return 700;
10905                                                }
10906                                            }
10907                                          else
10908                                            {
10909                                              /* 33222222222211111111110000000000
10910                                                 10987654321098765432109876543210
10911                                                 xxx11010xx0xxxxxx10111xxxxxxxxxx
10912                                                 crc32cx.  */
10913                                              return 734;
10914                                            }
10915                                        }
10916                                      else
10917                                        {
10918                                          /* 33222222222211111111110000000000
10919                                             10987654321098765432109876543210
10920                                             xxx11010xx0xxxxxxx1111xxxxxxxxxx
10921                                             autdzb.  */
10922                                          return 708;
10923                                        }
10924                                    }
10925                                }
10926                            }
10927                        }
10928                    }
10929                  else
10930                    {
10931                      if (((word >> 29) & 0x1) == 0)
10932                        {
10933                          if (((word >> 30) & 0x1) == 0)
10934                            {
10935                              /* 33222222222211111111110000000000
10936                                 10987654321098765432109876543210
10937                                 x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
10938                                 bic.  */
10939                              return 1003;
10940                            }
10941                          else
10942                            {
10943                              /* 33222222222211111111110000000000
10944                                 10987654321098765432109876543210
10945                                 x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
10946                                 eon.  */
10947                              return 1010;
10948                            }
10949                        }
10950                      else
10951                        {
10952                          if (((word >> 30) & 0x1) == 0)
10953                            {
10954                              /* 33222222222211111111110000000000
10955                                 10987654321098765432109876543210
10956                                 x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
10957                                 orn.  */
10958                              return 1007;
10959                            }
10960                          else
10961                            {
10962                              /* 33222222222211111111110000000000
10963                                 10987654321098765432109876543210
10964                                 x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
10965                                 bics.  */
10966                              return 1013;
10967                            }
10968                        }
10969                    }
10970                }
10971            }
10972          else
10973            {
10974              if (((word >> 27) & 0x1) == 0)
10975                {
10976                  if (((word >> 23) & 0x1) == 0)
10977                    {
10978                      if (((word >> 29) & 0x1) == 0)
10979                        {
10980                          if (((word >> 30) & 0x1) == 0)
10981                            {
10982                              /* 33222222222211111111110000000000
10983                                 10987654321098765432109876543210
10984                                 x00x00110xxxxxxxxxxxxxxxxxxxxxxx
10985                                 sbfm.  */
10986                              return 618;
10987                            }
10988                          else
10989                            {
10990                              /* 33222222222211111111110000000000
10991                                 10987654321098765432109876543210
10992                                 x10x00110xxxxxxxxxxxxxxxxxxxxxxx
10993                                 ubfm.  */
10994                              return 629;
10995                            }
10996                        }
10997                      else
10998                        {
10999                          /* 33222222222211111111110000000000
11000                             10987654321098765432109876543210
11001                             xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
11002                             bfm.  */
11003                          return 625;
11004                        }
11005                    }
11006                  else
11007                    {
11008                      /* 33222222222211111111110000000000
11009                         10987654321098765432109876543210
11010                         xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
11011                         extr.  */
11012                      return 758;
11013                    }
11014                }
11015              else
11016                {
11017                  if (((word >> 21) & 0x1) == 0)
11018                    {
11019                      if (((word >> 28) & 0x1) == 0)
11020                        {
11021                          if (((word >> 29) & 0x1) == 0)
11022                            {
11023                              if (((word >> 30) & 0x1) == 0)
11024                                {
11025                                  /* 33222222222211111111110000000000
11026                                     10987654321098765432109876543210
11027                                     x0001011xx0xxxxxxxxxxxxxxxxxxxxx
11028                                     add.  */
11029                                  return 21;
11030                                }
11031                              else
11032                                {
11033                                  /* 33222222222211111111110000000000
11034                                     10987654321098765432109876543210
11035                                     x1001011xx0xxxxxxxxxxxxxxxxxxxxx
11036                                     sub.  */
11037                                  return 24;
11038                                }
11039                            }
11040                          else
11041                            {
11042                              if (((word >> 30) & 0x1) == 0)
11043                                {
11044                                  /* 33222222222211111111110000000000
11045                                     10987654321098765432109876543210
11046                                     x0101011xx0xxxxxxxxxxxxxxxxxxxxx
11047                                     adds.  */
11048                                  return 22;
11049                                }
11050                              else
11051                                {
11052                                  /* 33222222222211111111110000000000
11053                                     10987654321098765432109876543210
11054                                     x1101011xx0xxxxxxxxxxxxxxxxxxxxx
11055                                     subs.  */
11056                                  return 26;
11057                                }
11058                            }
11059                        }
11060                      else
11061                        {
11062                          if (((word >> 15) & 0x1) == 0)
11063                            {
11064                              if (((word >> 22) & 0x1) == 0)
11065                                {
11066                                  /* 33222222222211111111110000000000
11067                                     10987654321098765432109876543210
11068                                     xxx11011x00xxxxx0xxxxxxxxxxxxxxx
11069                                     madd.  */
11070                                  return 735;
11071                                }
11072                              else
11073                                {
11074                                  if (((word >> 23) & 0x1) == 0)
11075                                    {
11076                                      /* 33222222222211111111110000000000
11077                                         10987654321098765432109876543210
11078                                         xxx11011010xxxxx0xxxxxxxxxxxxxxx
11079                                         smulh.  */
11080                                      return 743;
11081                                    }
11082                                  else
11083                                    {
11084                                      /* 33222222222211111111110000000000
11085                                         10987654321098765432109876543210
11086                                         xxx11011110xxxxx0xxxxxxxxxxxxxxx
11087                                         umulh.  */
11088                                      return 748;
11089                                    }
11090                                }
11091                            }
11092                          else
11093                            {
11094                              /* 33222222222211111111110000000000
11095                                 10987654321098765432109876543210
11096                                 xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
11097                                 msub.  */
11098                              return 737;
11099                            }
11100                        }
11101                    }
11102                  else
11103                    {
11104                      if (((word >> 23) & 0x1) == 0)
11105                        {
11106                          if (((word >> 28) & 0x1) == 0)
11107                            {
11108                              if (((word >> 29) & 0x1) == 0)
11109                                {
11110                                  if (((word >> 30) & 0x1) == 0)
11111                                    {
11112                                      /* 33222222222211111111110000000000
11113                                         10987654321098765432109876543210
11114                                         x00010110x1xxxxxxxxxxxxxxxxxxxxx
11115                                         add.  */
11116                                      return 6;
11117                                    }
11118                                  else
11119                                    {
11120                                      /* 33222222222211111111110000000000
11121                                         10987654321098765432109876543210
11122                                         x10010110x1xxxxxxxxxxxxxxxxxxxxx
11123                                         sub.  */
11124                                      return 9;
11125                                    }
11126                                }
11127                              else
11128                                {
11129                                  if (((word >> 30) & 0x1) == 0)
11130                                    {
11131                                      /* 33222222222211111111110000000000
11132                                         10987654321098765432109876543210
11133                                         x01010110x1xxxxxxxxxxxxxxxxxxxxx
11134                                         adds.  */
11135                                      return 7;
11136                                    }
11137                                  else
11138                                    {
11139                                      /* 33222222222211111111110000000000
11140                                         10987654321098765432109876543210
11141                                         x11010110x1xxxxxxxxxxxxxxxxxxxxx
11142                                         subs.  */
11143                                      return 10;
11144                                    }
11145                                }
11146                            }
11147                          else
11148                            {
11149                              if (((word >> 15) & 0x1) == 0)
11150                                {
11151                                  /* 33222222222211111111110000000000
11152                                     10987654321098765432109876543210
11153                                     xxx110110x1xxxxx0xxxxxxxxxxxxxxx
11154                                     smaddl.  */
11155                                  return 739;
11156                                }
11157                              else
11158                                {
11159                                  /* 33222222222211111111110000000000
11160                                     10987654321098765432109876543210
11161                                     xxx110110x1xxxxx1xxxxxxxxxxxxxxx
11162                                     smsubl.  */
11163                                  return 741;
11164                                }
11165                            }
11166                        }
11167                      else
11168                        {
11169                          if (((word >> 15) & 0x1) == 0)
11170                            {
11171                              /* 33222222222211111111110000000000
11172                                 10987654321098765432109876543210
11173                                 xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
11174                                 umaddl.  */
11175                              return 744;
11176                            }
11177                          else
11178                            {
11179                              /* 33222222222211111111110000000000
11180                                 10987654321098765432109876543210
11181                                 xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
11182                                 umsubl.  */
11183                              return 746;
11184                            }
11185                        }
11186                    }
11187                }
11188            }
11189        }
11190    }
11191  else
11192    {
11193      if (((word >> 27) & 0x1) == 0)
11194        {
11195          if (((word >> 28) & 0x1) == 0)
11196            {
11197              if (((word >> 24) & 0x1) == 0)
11198                {
11199                  if (((word >> 29) & 0x1) == 0)
11200                    {
11201                      if (((word >> 13) & 0x1) == 0)
11202                        {
11203                          if (((word >> 14) & 0x1) == 0)
11204                            {
11205                              if (((word >> 15) & 0x1) == 0)
11206                                {
11207                                  if (((word >> 21) & 0x1) == 0)
11208                                    {
11209                                      if (((word >> 30) & 0x1) == 0)
11210                                        {
11211                                          if (((word >> 31) & 0x1) == 0)
11212                                            {
11213                                              if (((word >> 16) & 0x1) == 0)
11214                                                {
11215                                                  if (((word >> 17) & 0x1) == 0)
11216                                                    {
11217                                                      if (((word >> 18) & 0x1) == 0)
11218                                                        {
11219                                                          if (((word >> 19) & 0x1) == 0)
11220                                                            {
11221                                                              if (((word >> 20) & 0x1) == 0)
11222                                                                {
11223                                                                  /* 33222222222211111111110000000000
11224                                                                     10987654321098765432109876543210
11225                                                                     000001x0xx000000000xxxxxxxxxxxxx
11226                                                                     add.  */
11227                                                                  return 1330;
11228                                                                }
11229                                                              else
11230                                                                {
11231                                                                  /* 33222222222211111111110000000000
11232                                                                     10987654321098765432109876543210
11233                                                                     000001x0xx010000000xxxxxxxxxxxxx
11234                                                                     mul.  */
11235                                                                  return 1800;
11236                                                                }
11237                                                            }
11238                                                          else
11239                                                            {
11240                                                              if (((word >> 20) & 0x1) == 0)
11241                                                                {
11242                                                                  /* 33222222222211111111110000000000
11243                                                                     10987654321098765432109876543210
11244                                                                     000001x0xx001000000xxxxxxxxxxxxx
11245                                                                     smax.  */
11246                                                                  return 1880;
11247                                                                }
11248                                                              else
11249                                                                {
11250                                                                  /* 33222222222211111111110000000000
11251                                                                     10987654321098765432109876543210
11252                                                                     000001x0xx011000000xxxxxxxxxxxxx
11253                                                                     orr.  */
11254                                                                  return 1811;
11255                                                                }
11256                                                            }
11257                                                        }
11258                                                      else
11259                                                        {
11260                                                          if (((word >> 19) & 0x1) == 0)
11261                                                            {
11262                                                              /* 33222222222211111111110000000000
11263                                                                 10987654321098765432109876543210
11264                                                                 000001x0xx0x0100000xxxxxxxxxxxxx
11265                                                                 sdiv.  */
11266                                                              return 1871;
11267                                                            }
11268                                                          else
11269                                                            {
11270                                                              /* 33222222222211111111110000000000
11271                                                                 10987654321098765432109876543210
11272                                                                 000001x0xx0x1100000xxxxxxxxxxxxx
11273                                                                 sabd.  */
11274                                                              return 1862;
11275                                                            }
11276                                                        }
11277                                                    }
11278                                                  else
11279                                                    {
11280                                                      if (((word >> 18) & 0x1) == 0)
11281                                                        {
11282                                                          if (((word >> 19) & 0x1) == 0)
11283                                                            {
11284                                                              /* 33222222222211111111110000000000
11285                                                                 10987654321098765432109876543210
11286                                                                 000001x0xx0x0010000xxxxxxxxxxxxx
11287                                                                 smulh.  */
11288                                                              return 1885;
11289                                                            }
11290                                                          else
11291                                                            {
11292                                                              if (((word >> 20) & 0x1) == 0)
11293                                                                {
11294                                                                  /* 33222222222211111111110000000000
11295                                                                     10987654321098765432109876543210
11296                                                                     000001x0xx001010000xxxxxxxxxxxxx
11297                                                                     smin.  */
11298                                                                  return 1883;
11299                                                                }
11300                                                              else
11301                                                                {
11302                                                                  /* 33222222222211111111110000000000
11303                                                                     10987654321098765432109876543210
11304                                                                     000001x0xx011010000xxxxxxxxxxxxx
11305                                                                     and.  */
11306                                                                  return 1338;
11307                                                                }
11308                                                            }
11309                                                        }
11310                                                      else
11311                                                        {
11312                                                          /* 33222222222211111111110000000000
11313                                                             10987654321098765432109876543210
11314                                                             000001x0xx0xx110000xxxxxxxxxxxxx
11315                                                             sdivr.  */
11316                                                          return 1872;
11317                                                        }
11318                                                    }
11319                                                }
11320                                              else
11321                                                {
11322                                                  if (((word >> 17) & 0x1) == 0)
11323                                                    {
11324                                                      if (((word >> 18) & 0x1) == 0)
11325                                                        {
11326                                                          if (((word >> 19) & 0x1) == 0)
11327                                                            {
11328                                                              /* 33222222222211111111110000000000
11329                                                                 10987654321098765432109876543210
11330                                                                 000001x0xx0x0001000xxxxxxxxxxxxx
11331                                                                 sub.  */
11332                                                              return 2002;
11333                                                            }
11334                                                          else
11335                                                            {
11336                                                              if (((word >> 20) & 0x1) == 0)
11337                                                                {
11338                                                                  /* 33222222222211111111110000000000
11339                                                                     10987654321098765432109876543210
11340                                                                     000001x0xx001001000xxxxxxxxxxxxx
11341                                                                     umax.  */
11342                                                                  return 2030;
11343                                                                }
11344                                                              else
11345                                                                {
11346                                                                  /* 33222222222211111111110000000000
11347                                                                     10987654321098765432109876543210
11348                                                                     000001x0xx011001000xxxxxxxxxxxxx
11349                                                                     eor.  */
11350                                                                  return 1425;
11351                                                                }
11352                                                            }
11353                                                        }
11354                                                      else
11355                                                        {
11356                                                          if (((word >> 19) & 0x1) == 0)
11357                                                            {
11358                                                              /* 33222222222211111111110000000000
11359                                                                 10987654321098765432109876543210
11360                                                                 000001x0xx0x0101000xxxxxxxxxxxxx
11361                                                                 udiv.  */
11362                                                              return 2024;
11363                                                            }
11364                                                          else
11365                                                            {
11366                                                              /* 33222222222211111111110000000000
11367                                                                 10987654321098765432109876543210
11368                                                                 000001x0xx0x1101000xxxxxxxxxxxxx
11369                                                                 uabd.  */
11370                                                              return 2015;
11371                                                            }
11372                                                        }
11373                                                    }
11374                                                  else
11375                                                    {
11376                                                      if (((word >> 18) & 0x1) == 0)
11377                                                        {
11378                                                          if (((word >> 19) & 0x1) == 0)
11379                                                            {
11380                                                              if (((word >> 20) & 0x1) == 0)
11381                                                                {
11382                                                                  /* 33222222222211111111110000000000
11383                                                                     10987654321098765432109876543210
11384                                                                     000001x0xx000011000xxxxxxxxxxxxx
11385                                                                     subr.  */
11386                                                                  return 2004;
11387                                                                }
11388                                                              else
11389                                                                {
11390                                                                  /* 33222222222211111111110000000000
11391                                                                     10987654321098765432109876543210
11392                                                                     000001x0xx010011000xxxxxxxxxxxxx
11393                                                                     umulh.  */
11394                                                                  return 2035;
11395                                                                }
11396                                                            }
11397                                                          else
11398                                                            {
11399                                                              if (((word >> 20) & 0x1) == 0)
11400                                                                {
11401                                                                  /* 33222222222211111111110000000000
11402                                                                     10987654321098765432109876543210
11403                                                                     000001x0xx001011000xxxxxxxxxxxxx
11404                                                                     umin.  */
11405                                                                  return 2033;
11406                                                                }
11407                                                              else
11408                                                                {
11409                                                                  /* 33222222222211111111110000000000
11410                                                                     10987654321098765432109876543210
11411                                                                     000001x0xx011011000xxxxxxxxxxxxx
11412                                                                     bic.  */
11413                                                                  return 1350;
11414                                                                }
11415                                                            }
11416                                                        }
11417                                                      else
11418                                                        {
11419                                                          /* 33222222222211111111110000000000
11420                                                             10987654321098765432109876543210
11421                                                             000001x0xx0xx111000xxxxxxxxxxxxx
11422                                                             udivr.  */
11423                                                          return 2025;
11424                                                        }
11425                                                    }
11426                                                }
11427                                            }
11428                                          else
11429                                            {
11430                                              if (((word >> 23) & 0x1) == 0)
11431                                                {
11432                                                  /* 33222222222211111111110000000000
11433                                                     10987654321098765432109876543210
11434                                                     100001x00x0xxxxx000xxxxxxxxxxxxx
11435                                                     ld1sb.  */
11436                                                  return 1612;
11437                                                }
11438                                              else
11439                                                {
11440                                                  /* 33222222222211111111110000000000
11441                                                     10987654321098765432109876543210
11442                                                     100001x01x0xxxxx000xxxxxxxxxxxxx
11443                                                     ld1sh.  */
11444                                                  return 1623;
11445                                                }
11446                                            }
11447                                        }
11448                                      else
11449                                        {
11450                                          if (((word >> 31) & 0x1) == 0)
11451                                            {
11452                                              if (((word >> 12) & 0x1) == 0)
11453                                                {
11454                                                  if (((word >> 10) & 0x1) == 0)
11455                                                    {
11456                                                      if (((word >> 11) & 0x1) == 0)
11457                                                        {
11458                                                          /* 33222222222211111111110000000000
11459                                                             10987654321098765432109876543210
11460                                                             010001x0xx0xxxxx000000xxxxxxxxxx
11461                                                             sdot.  */
11462                                                          return 1873;
11463                                                        }
11464                                                      else
11465                                                        {
11466                                                          /* 33222222222211111111110000000000
11467                                                             10987654321098765432109876543210
11468                                                             010001x0xx0xxxxx000010xxxxxxxxxx
11469                                                             sqdmlalbt.  */
11470                                                          return 2224;
11471                                                        }
11472                                                    }
11473                                                  else
11474                                                    {
11475                                                      if (((word >> 11) & 0x1) == 0)
11476                                                        {
11477                                                          /* 33222222222211111111110000000000
11478                                                             10987654321098765432109876543210
11479                                                             010001x0xx0xxxxx000001xxxxxxxxxx
11480                                                             udot.  */
11481                                                          return 2026;
11482                                                        }
11483                                                      else
11484                                                        {
11485                                                          /* 33222222222211111111110000000000
11486                                                             10987654321098765432109876543210
11487                                                             010001x0xx0xxxxx000011xxxxxxxxxx
11488                                                             sqdmlslbt.  */
11489                                                          return 2231;
11490                                                        }
11491                                                    }
11492                                                }
11493                                              else
11494                                                {
11495                                                  /* 33222222222211111111110000000000
11496                                                     10987654321098765432109876543210
11497                                                     010001x0xx0xxxxx0001xxxxxxxxxxxx
11498                                                     cdot.  */
11499                                                  return 2113;
11500                                                }
11501                                            }
11502                                          else
11503                                            {
11504                                              if (((word >> 23) & 0x1) == 0)
11505                                                {
11506                                                  /* 33222222222211111111110000000000
11507                                                     10987654321098765432109876543210
11508                                                     110001x00x0xxxxx000xxxxxxxxxxxxx
11509                                                     ld1sb.  */
11510                                                  return 1616;
11511                                                }
11512                                              else
11513                                                {
11514                                                  /* 33222222222211111111110000000000
11515                                                     10987654321098765432109876543210
11516                                                     110001x01x0xxxxx000xxxxxxxxxxxxx
11517                                                     ld1sh.  */
11518                                                  return 1627;
11519                                                }
11520                                            }
11521                                        }
11522                                    }
11523                                  else
11524                                    {
11525                                      if (((word >> 30) & 0x1) == 0)
11526                                        {
11527                                          if (((word >> 31) & 0x1) == 0)
11528                                            {
11529                                              if (((word >> 10) & 0x1) == 0)
11530                                                {
11531                                                  if (((word >> 11) & 0x1) == 0)
11532                                                    {
11533                                                      if (((word >> 12) & 0x1) == 0)
11534                                                        {
11535                                                          /* 33222222222211111111110000000000
11536                                                             10987654321098765432109876543210
11537                                                             000001x0xx1xxxxx000000xxxxxxxxxx
11538                                                             add.  */
11539                                                          return 1328;
11540                                                        }
11541                                                      else
11542                                                        {
11543                                                          /* 33222222222211111111110000000000
11544                                                             10987654321098765432109876543210
11545                                                             000001x0xx1xxxxx000100xxxxxxxxxx
11546                                                             sqadd.  */
11547                                                          return 1887;
11548                                                        }
11549                                                    }
11550                                                  else
11551                                                    {
11552                                                      /* 33222222222211111111110000000000
11553                                                         10987654321098765432109876543210
11554                                                         000001x0xx1xxxxx000x10xxxxxxxxxx
11555                                                         sqsub.  */
11556                                                      return 1917;
11557                                                    }
11558                                                }
11559                                              else
11560                                                {
11561                                                  if (((word >> 11) & 0x1) == 0)
11562                                                    {
11563                                                      if (((word >> 12) & 0x1) == 0)
11564                                                        {
11565                                                          /* 33222222222211111111110000000000
11566                                                             10987654321098765432109876543210
11567                                                             000001x0xx1xxxxx000001xxxxxxxxxx
11568                                                             sub.  */
11569                                                          return 2000;
11570                                                        }
11571                                                      else
11572                                                        {
11573                                                          /* 33222222222211111111110000000000
11574                                                             10987654321098765432109876543210
11575                                                             000001x0xx1xxxxx000101xxxxxxxxxx
11576                                                             uqadd.  */
11577                                                          return 2036;
11578                                                        }
11579                                                    }
11580                                                  else
11581                                                    {
11582                                                      /* 33222222222211111111110000000000
11583                                                         10987654321098765432109876543210
11584                                                         000001x0xx1xxxxx000x11xxxxxxxxxx
11585                                                         uqsub.  */
11586                                                      return 2066;
11587                                                    }
11588                                                }
11589                                            }
11590                                          else
11591                                            {
11592                                              if (((word >> 23) & 0x1) == 0)
11593                                                {
11594                                                  /* 33222222222211111111110000000000
11595                                                     10987654321098765432109876543210
11596                                                     100001x00x1xxxxx000xxxxxxxxxxxxx
11597                                                     prfb.  */
11598                                                  return 1820;
11599                                                }
11600                                              else
11601                                                {
11602                                                  /* 33222222222211111111110000000000
11603                                                     10987654321098765432109876543210
11604                                                     100001x01x1xxxxx000xxxxxxxxxxxxx
11605                                                     ld1sh.  */
11606                                                  return 1624;
11607                                                }
11608                                            }
11609                                        }
11610                                      else
11611                                        {
11612                                          if (((word >> 23) & 0x1) == 0)
11613                                            {
11614                                              if (((word >> 31) & 0x1) == 0)
11615                                                {
11616                                                  if (((word >> 10) & 0x1) == 0)
11617                                                    {
11618                                                      if (((word >> 11) & 0x1) == 0)
11619                                                        {
11620                                                          /* 33222222222211111111110000000000
11621                                                             10987654321098765432109876543210
11622                                                             010001x00x1xxxxx000x00xxxxxxxxxx
11623                                                             sqrdmlah.  */
11624                                                          return 2249;
11625                                                        }
11626                                                      else
11627                                                        {
11628                                                          /* 33222222222211111111110000000000
11629                                                             10987654321098765432109876543210
11630                                                             010001x00x1xxxxx000x10xxxxxxxxxx
11631                                                             mla.  */
11632                                                          return 2156;
11633                                                        }
11634                                                    }
11635                                                  else
11636                                                    {
11637                                                      if (((word >> 11) & 0x1) == 0)
11638                                                        {
11639                                                          /* 33222222222211111111110000000000
11640                                                             10987654321098765432109876543210
11641                                                             010001x00x1xxxxx000x01xxxxxxxxxx
11642                                                             sqrdmlsh.  */
11643                                                          return 2253;
11644                                                        }
11645                                                      else
11646                                                        {
11647                                                          /* 33222222222211111111110000000000
11648                                                             10987654321098765432109876543210
11649                                                             010001x00x1xxxxx000x11xxxxxxxxxx
11650                                                             mls.  */
11651                                                          return 2159;
11652                                                        }
11653                                                    }
11654                                                }
11655                                              else
11656                                                {
11657                                                  /* 33222222222211111111110000000000
11658                                                     10987654321098765432109876543210
11659                                                     110001x00x1xxxxx000xxxxxxxxxxxxx
11660                                                     prfb.  */
11661                                                  return 1821;
11662                                                }
11663                                            }
11664                                          else
11665                                            {
11666                                              if (((word >> 31) & 0x1) == 0)
11667                                                {
11668                                                  if (((word >> 10) & 0x1) == 0)
11669                                                    {
11670                                                      if (((word >> 11) & 0x1) == 0)
11671                                                        {
11672                                                          if (((word >> 12) & 0x1) == 0)
11673                                                            {
11674                                                              if (((word >> 22) & 0x1) == 0)
11675                                                                {
11676                                                                  /* 33222222222211111111110000000000
11677                                                                     10987654321098765432109876543210
11678                                                                     010001x0101xxxxx000000xxxxxxxxxx
11679                                                                     sdot.  */
11680                                                                  return 1874;
11681                                                                }
11682                                                              else
11683                                                                {
11684                                                                  /* 33222222222211111111110000000000
11685                                                                     10987654321098765432109876543210
11686                                                                     010001x0111xxxxx000000xxxxxxxxxx
11687                                                                     sdot.  */
11688                                                                  return 1875;
11689                                                                }
11690                                                            }
11691                                                          else
11692                                                            {
11693                                                              if (((word >> 22) & 0x1) == 0)
11694                                                                {
11695                                                                  /* 33222222222211111111110000000000
11696                                                                     10987654321098765432109876543210
11697                                                                     010001x0101xxxxx000100xxxxxxxxxx
11698                                                                     sqrdmlah.  */
11699                                                                  return 2250;
11700                                                                }
11701                                                              else
11702                                                                {
11703                                                                  /* 33222222222211111111110000000000
11704                                                                     10987654321098765432109876543210
11705                                                                     010001x0111xxxxx000100xxxxxxxxxx
11706                                                                     sqrdmlah.  */
11707                                                                  return 2251;
11708                                                                }
11709                                                            }
11710                                                        }
11711                                                      else
11712                                                        {
11713                                                          if (((word >> 12) & 0x1) == 0)
11714                                                            {
11715                                                              if (((word >> 22) & 0x1) == 0)
11716                                                                {
11717                                                                  /* 33222222222211111111110000000000
11718                                                                     10987654321098765432109876543210
11719                                                                     010001x0101xxxxx000010xxxxxxxxxx
11720                                                                     mla.  */
11721                                                                  return 2157;
11722                                                                }
11723                                                              else
11724                                                                {
11725                                                                  /* 33222222222211111111110000000000
11726                                                                     10987654321098765432109876543210
11727                                                                     010001x0111xxxxx000010xxxxxxxxxx
11728                                                                     mla.  */
11729                                                                  return 2158;
11730                                                                }
11731                                                            }
11732                                                          else
11733                                                            {
11734                                                              /* 33222222222211111111110000000000
11735                                                                 10987654321098765432109876543210
11736                                                                 010001x01x1xxxxx000110xxxxxxxxxx
11737                                                                 usdot.  */
11738                                                              return 3030;
11739                                                            }
11740                                                        }
11741                                                    }
11742                                                  else
11743                                                    {
11744                                                      if (((word >> 11) & 0x1) == 0)
11745                                                        {
11746                                                          if (((word >> 12) & 0x1) == 0)
11747                                                            {
11748                                                              if (((word >> 22) & 0x1) == 0)
11749                                                                {
11750                                                                  /* 33222222222211111111110000000000
11751                                                                     10987654321098765432109876543210
11752                                                                     010001x0101xxxxx000001xxxxxxxxxx
11753                                                                     udot.  */
11754                                                                  return 2027;
11755                                                                }
11756                                                              else
11757                                                                {
11758                                                                  /* 33222222222211111111110000000000
11759                                                                     10987654321098765432109876543210
11760                                                                     010001x0111xxxxx000001xxxxxxxxxx
11761                                                                     udot.  */
11762                                                                  return 2028;
11763                                                                }
11764                                                            }
11765                                                          else
11766                                                            {
11767                                                              if (((word >> 22) & 0x1) == 0)
11768                                                                {
11769                                                                  /* 33222222222211111111110000000000
11770                                                                     10987654321098765432109876543210
11771                                                                     010001x0101xxxxx000101xxxxxxxxxx
11772                                                                     sqrdmlsh.  */
11773                                                                  return 2254;
11774                                                                }
11775                                                              else
11776                                                                {
11777                                                                  /* 33222222222211111111110000000000
11778                                                                     10987654321098765432109876543210
11779                                                                     010001x0111xxxxx000101xxxxxxxxxx
11780                                                                     sqrdmlsh.  */
11781                                                                  return 2255;
11782                                                                }
11783                                                            }
11784                                                        }
11785                                                      else
11786                                                        {
11787                                                          if (((word >> 12) & 0x1) == 0)
11788                                                            {
11789                                                              if (((word >> 22) & 0x1) == 0)
11790                                                                {
11791                                                                  /* 33222222222211111111110000000000
11792                                                                     10987654321098765432109876543210
11793                                                                     010001x0101xxxxx000011xxxxxxxxxx
11794                                                                     mls.  */
11795                                                                  return 2160;
11796                                                                }
11797                                                              else
11798                                                                {
11799                                                                  /* 33222222222211111111110000000000
11800                                                                     10987654321098765432109876543210
11801                                                                     010001x0111xxxxx000011xxxxxxxxxx
11802                                                                     mls.  */
11803                                                                  return 2161;
11804                                                                }
11805                                                            }
11806                                                          else
11807                                                            {
11808                                                              /* 33222222222211111111110000000000
11809                                                                 10987654321098765432109876543210
11810                                                                 010001x01x1xxxxx000111xxxxxxxxxx
11811                                                                 sudot.  */
11812                                                              return 3031;
11813                                                            }
11814                                                        }
11815                                                    }
11816                                                }
11817                                              else
11818                                                {
11819                                                  /* 33222222222211111111110000000000
11820                                                     10987654321098765432109876543210
11821                                                     110001x01x1xxxxx000xxxxxxxxxxxxx
11822                                                     ld1sh.  */
11823                                                  return 1628;
11824                                                }
11825                                            }
11826                                        }
11827                                    }
11828                                }
11829                              else
11830                                {
11831                                  if (((word >> 31) & 0x1) == 0)
11832                                    {
11833                                      if (((word >> 21) & 0x1) == 0)
11834                                        {
11835                                          if (((word >> 16) & 0x1) == 0)
11836                                            {
11837                                              if (((word >> 17) & 0x1) == 0)
11838                                                {
11839                                                  if (((word >> 18) & 0x1) == 0)
11840                                                    {
11841                                                      if (((word >> 19) & 0x1) == 0)
11842                                                        {
11843                                                          if (((word >> 20) & 0x1) == 0)
11844                                                            {
11845                                                              /* 33222222222211111111110000000000
11846                                                                 10987654321098765432109876543210
11847                                                                 0x0001x0xx000000100xxxxxxxxxxxxx
11848                                                                 asr.  */
11849                                                              return 1346;
11850                                                            }
11851                                                          else
11852                                                            {
11853                                                              if (((word >> 30) & 0x1) == 0)
11854                                                                {
11855                                                                  /* 33222222222211111111110000000000
11856                                                                     10987654321098765432109876543210
11857                                                                     000001x0xx010000100xxxxxxxxxxxxx
11858                                                                     asr.  */
11859                                                                  return 1344;
11860                                                                }
11861                                                              else
11862                                                                {
11863                                                                  /* 33222222222211111111110000000000
11864                                                                     10987654321098765432109876543210
11865                                                                     010001x0xx010000100xxxxxxxxxxxxx
11866                                                                     shadd.  */
11867                                                                  return 2190;
11868                                                                }
11869                                                            }
11870                                                        }
11871                                                      else
11872                                                        {
11873                                                          if (((word >> 20) & 0x1) == 0)
11874                                                            {
11875                                                              /* 33222222222211111111110000000000
11876                                                                 10987654321098765432109876543210
11877                                                                 0x0001x0xx001000100xxxxxxxxxxxxx
11878                                                                 sqshl.  */
11879                                                              return 2268;
11880                                                            }
11881                                                          else
11882                                                            {
11883                                                              if (((word >> 30) & 0x1) == 0)
11884                                                                {
11885                                                                  /* 33222222222211111111110000000000
11886                                                                     10987654321098765432109876543210
11887                                                                     000001x0xx011000100xxxxxxxxxxxxx
11888                                                                     asr.  */
11889                                                                  return 1345;
11890                                                                }
11891                                                              else
11892                                                                {
11893                                                                  /* 33222222222211111111110000000000
11894                                                                     10987654321098765432109876543210
11895                                                                     010001x0xx011000100xxxxxxxxxxxxx
11896                                                                     sqadd.  */
11897                                                                  return 2219;
11898                                                                }
11899                                                            }
11900                                                        }
11901                                                    }
11902                                                  else
11903                                                    {
11904                                                      if (((word >> 19) & 0x1) == 0)
11905                                                        {
11906                                                          if (((word >> 20) & 0x1) == 0)
11907                                                            {
11908                                                              /* 33222222222211111111110000000000
11909                                                                 10987654321098765432109876543210
11910                                                                 0x0001x0xx000100100xxxxxxxxxxxxx
11911                                                                 asrd.  */
11912                                                              return 1347;
11913                                                            }
11914                                                          else
11915                                                            {
11916                                                              if (((word >> 30) & 0x1) == 0)
11917                                                                {
11918                                                                  /* 33222222222211111111110000000000
11919                                                                     10987654321098765432109876543210
11920                                                                     000001x0xx010100100xxxxxxxxxxxxx
11921                                                                     asrr.  */
11922                                                                  return 1348;
11923                                                                }
11924                                                              else
11925                                                                {
11926                                                                  /* 33222222222211111111110000000000
11927                                                                     10987654321098765432109876543210
11928                                                                     010001x0xx010100100xxxxxxxxxxxxx
11929                                                                     srhadd.  */
11930                                                                  return 2281;
11931                                                                }
11932                                                            }
11933                                                        }
11934                                                      else
11935                                                        {
11936                                                          if (((word >> 20) & 0x1) == 0)
11937                                                            {
11938                                                              if (((word >> 30) & 0x1) == 0)
11939                                                                {
11940                                                                  /* 33222222222211111111110000000000
11941                                                                     10987654321098765432109876543210
11942                                                                     000001x0xx001100100xxxxxxxxxxxxx
11943                                                                     srshr.  */
11944                                                                  return 2285;
11945                                                                }
11946                                                              else
11947                                                                {
11948                                                                  /* 33222222222211111111110000000000
11949                                                                     10987654321098765432109876543210
11950                                                                     010001x0xx001100100xxxxxxxxxxxxx
11951                                                                     sqshlr.  */
11952                                                                  return 2269;
11953                                                                }
11954                                                            }
11955                                                          else
11956                                                            {
11957                                                              /* 33222222222211111111110000000000
11958                                                                 10987654321098765432109876543210
11959                                                                 0x0001x0xx011100100xxxxxxxxxxxxx
11960                                                                 suqadd.  */
11961                                                              return 2305;
11962                                                            }
11963                                                        }
11964                                                    }
11965                                                }
11966                                              else
11967                                                {
11968                                                  if (((word >> 18) & 0x1) == 0)
11969                                                    {
11970                                                      if (((word >> 19) & 0x1) == 0)
11971                                                        {
11972                                                          if (((word >> 20) & 0x1) == 0)
11973                                                            {
11974                                                              /* 33222222222211111111110000000000
11975                                                                 10987654321098765432109876543210
11976                                                                 0x0001x0xx000010100xxxxxxxxxxxxx
11977                                                                 srshl.  */
11978                                                              return 2283;
11979                                                            }
11980                                                          else
11981                                                            {
11982                                                              /* 33222222222211111111110000000000
11983                                                                 10987654321098765432109876543210
11984                                                                 0x0001x0xx010010100xxxxxxxxxxxxx
11985                                                                 shsub.  */
11986                                                              return 2193;
11987                                                            }
11988                                                        }
11989                                                      else
11990                                                        {
11991                                                          if (((word >> 20) & 0x1) == 0)
11992                                                            {
11993                                                              /* 33222222222211111111110000000000
11994                                                                 10987654321098765432109876543210
11995                                                                 0x0001x0xx001010100xxxxxxxxxxxxx
11996                                                                 sqrshl.  */
11997                                                              return 2261;
11998                                                            }
11999                                                          else
12000                                                            {
12001                                                              /* 33222222222211111111110000000000
12002                                                                 10987654321098765432109876543210
12003                                                                 0x0001x0xx011010100xxxxxxxxxxxxx
12004                                                                 sqsub.  */
12005                                                              return 2275;
12006                                                            }
12007                                                        }
12008                                                    }
12009                                                  else
12010                                                    {
12011                                                      if (((word >> 19) & 0x1) == 0)
12012                                                        {
12013                                                          if (((word >> 20) & 0x1) == 0)
12014                                                            {
12015                                                              if (((word >> 30) & 0x1) == 0)
12016                                                                {
12017                                                                  /* 33222222222211111111110000000000
12018                                                                     10987654321098765432109876543210
12019                                                                     000001x0xx000110100xxxxxxxxxxxxx
12020                                                                     sqshl.  */
12021                                                                  return 2267;
12022                                                                }
12023                                                              else
12024                                                                {
12025                                                                  /* 33222222222211111111110000000000
12026                                                                     10987654321098765432109876543210
12027                                                                     010001x0xx000110100xxxxxxxxxxxxx
12028                                                                     srshlr.  */
12029                                                                  return 2284;
12030                                                                }
12031                                                            }
12032                                                          else
12033                                                            {
12034                                                              /* 33222222222211111111110000000000
12035                                                                 10987654321098765432109876543210
12036                                                                 0x0001x0xx010110100xxxxxxxxxxxxx
12037                                                                 shsubr.  */
12038                                                              return 2194;
12039                                                            }
12040                                                        }
12041                                                      else
12042                                                        {
12043                                                          if (((word >> 20) & 0x1) == 0)
12044                                                            {
12045                                                              /* 33222222222211111111110000000000
12046                                                                 10987654321098765432109876543210
12047                                                                 0x0001x0xx001110100xxxxxxxxxxxxx
12048                                                                 sqrshlr.  */
12049                                                              return 2262;
12050                                                            }
12051                                                          else
12052                                                            {
12053                                                              /* 33222222222211111111110000000000
12054                                                                 10987654321098765432109876543210
12055                                                                 0x0001x0xx011110100xxxxxxxxxxxxx
12056                                                                 sqsubr.  */
12057                                                              return 2276;
12058                                                            }
12059                                                        }
12060                                                    }
12061                                                }
12062                                            }
12063                                          else
12064                                            {
12065                                              if (((word >> 17) & 0x1) == 0)
12066                                                {
12067                                                  if (((word >> 18) & 0x1) == 0)
12068                                                    {
12069                                                      if (((word >> 19) & 0x1) == 0)
12070                                                        {
12071                                                          if (((word >> 20) & 0x1) == 0)
12072                                                            {
12073                                                              /* 33222222222211111111110000000000
12074                                                                 10987654321098765432109876543210
12075                                                                 0x0001x0xx000001100xxxxxxxxxxxxx
12076                                                                 lsr.  */
12077                                                              return 1791;
12078                                                            }
12079                                                          else
12080                                                            {
12081                                                              if (((word >> 30) & 0x1) == 0)
12082                                                                {
12083                                                                  /* 33222222222211111111110000000000
12084                                                                     10987654321098765432109876543210
12085                                                                     000001x0xx010001100xxxxxxxxxxxxx
12086                                                                     lsr.  */
12087                                                                  return 1789;
12088                                                                }
12089                                                              else
12090                                                                {
12091                                                                  /* 33222222222211111111110000000000
12092                                                                     10987654321098765432109876543210
12093                                                                     010001x0xx010001100xxxxxxxxxxxxx
12094                                                                     uhadd.  */
12095                                                                  return 2318;
12096                                                                }
12097                                                            }
12098                                                        }
12099                                                      else
12100                                                        {
12101                                                          if (((word >> 20) & 0x1) == 0)
12102                                                            {
12103                                                              /* 33222222222211111111110000000000
12104                                                                 10987654321098765432109876543210
12105                                                                 0x0001x0xx001001100xxxxxxxxxxxxx
12106                                                                 uqshl.  */
12107                                                              return 2348;
12108                                                            }
12109                                                          else
12110                                                            {
12111                                                              if (((word >> 30) & 0x1) == 0)
12112                                                                {
12113                                                                  /* 33222222222211111111110000000000
12114                                                                     10987654321098765432109876543210
12115                                                                     000001x0xx011001100xxxxxxxxxxxxx
12116                                                                     lsr.  */
12117                                                                  return 1790;
12118                                                                }
12119                                                              else
12120                                                                {
12121                                                                  /* 33222222222211111111110000000000
12122                                                                     10987654321098765432109876543210
12123                                                                     010001x0xx011001100xxxxxxxxxxxxx
12124                                                                     uqadd.  */
12125                                                                  return 2342;
12126                                                                }
12127                                                            }
12128                                                        }
12129                                                    }
12130                                                  else
12131                                                    {
12132                                                      if (((word >> 19) & 0x1) == 0)
12133                                                        {
12134                                                          if (((word >> 30) & 0x1) == 0)
12135                                                            {
12136                                                              /* 33222222222211111111110000000000
12137                                                                 10987654321098765432109876543210
12138                                                                 000001x0xx0x0101100xxxxxxxxxxxxx
12139                                                                 lsrr.  */
12140                                                              return 1792;
12141                                                            }
12142                                                          else
12143                                                            {
12144                                                              /* 33222222222211111111110000000000
12145                                                                 10987654321098765432109876543210
12146                                                                 010001x0xx0x0101100xxxxxxxxxxxxx
12147                                                                 urhadd.  */
12148                                                              return 2357;
12149                                                            }
12150                                                        }
12151                                                      else
12152                                                        {
12153                                                          if (((word >> 20) & 0x1) == 0)
12154                                                            {
12155                                                              if (((word >> 30) & 0x1) == 0)
12156                                                                {
12157                                                                  /* 33222222222211111111110000000000
12158                                                                     10987654321098765432109876543210
12159                                                                     000001x0xx001101100xxxxxxxxxxxxx
12160                                                                     urshr.  */
12161                                                                  return 2360;
12162                                                                }
12163                                                              else
12164                                                                {
12165                                                                  /* 33222222222211111111110000000000
12166                                                                     10987654321098765432109876543210
12167                                                                     010001x0xx001101100xxxxxxxxxxxxx
12168                                                                     uqshlr.  */
12169                                                                  return 2349;
12170                                                                }
12171                                                            }
12172                                                          else
12173                                                            {
12174                                                              /* 33222222222211111111110000000000
12175                                                                 10987654321098765432109876543210
12176                                                                 0x0001x0xx011101100xxxxxxxxxxxxx
12177                                                                 usqadd.  */
12178                                                              return 2365;
12179                                                            }
12180                                                        }
12181                                                    }
12182                                                }
12183                                              else
12184                                                {
12185                                                  if (((word >> 18) & 0x1) == 0)
12186                                                    {
12187                                                      if (((word >> 19) & 0x1) == 0)
12188                                                        {
12189                                                          if (((word >> 20) & 0x1) == 0)
12190                                                            {
12191                                                              if (((word >> 30) & 0x1) == 0)
12192                                                                {
12193                                                                  /* 33222222222211111111110000000000
12194                                                                     10987654321098765432109876543210
12195                                                                     000001x0xx000011100xxxxxxxxxxxxx
12196                                                                     lsl.  */
12197                                                                  return 1785;
12198                                                                }
12199                                                              else
12200                                                                {
12201                                                                  /* 33222222222211111111110000000000
12202                                                                     10987654321098765432109876543210
12203                                                                     010001x0xx000011100xxxxxxxxxxxxx
12204                                                                     urshl.  */
12205                                                                  return 2358;
12206                                                                }
12207                                                            }
12208                                                          else
12209                                                            {
12210                                                              if (((word >> 30) & 0x1) == 0)
12211                                                                {
12212                                                                  /* 33222222222211111111110000000000
12213                                                                     10987654321098765432109876543210
12214                                                                     000001x0xx010011100xxxxxxxxxxxxx
12215                                                                     lsl.  */
12216                                                                  return 1783;
12217                                                                }
12218                                                              else
12219                                                                {
12220                                                                  /* 33222222222211111111110000000000
12221                                                                     10987654321098765432109876543210
12222                                                                     010001x0xx010011100xxxxxxxxxxxxx
12223                                                                     uhsub.  */
12224                                                                  return 2319;
12225                                                                }
12226                                                            }
12227                                                        }
12228                                                      else
12229                                                        {
12230                                                          if (((word >> 20) & 0x1) == 0)
12231                                                            {
12232                                                              /* 33222222222211111111110000000000
12233                                                                 10987654321098765432109876543210
12234                                                                 0x0001x0xx001011100xxxxxxxxxxxxx
12235                                                                 uqrshl.  */
12236                                                              return 2343;
12237                                                            }
12238                                                          else
12239                                                            {
12240                                                              if (((word >> 30) & 0x1) == 0)
12241                                                                {
12242                                                                  /* 33222222222211111111110000000000
12243                                                                     10987654321098765432109876543210
12244                                                                     000001x0xx011011100xxxxxxxxxxxxx
12245                                                                     lsl.  */
12246                                                                  return 1784;
12247                                                                }
12248                                                              else
12249                                                                {
12250                                                                  /* 33222222222211111111110000000000
12251                                                                     10987654321098765432109876543210
12252                                                                     010001x0xx011011100xxxxxxxxxxxxx
12253                                                                     uqsub.  */
12254                                                                  return 2352;
12255                                                                }
12256                                                            }
12257                                                        }
12258                                                    }
12259                                                  else
12260                                                    {
12261                                                      if (((word >> 19) & 0x1) == 0)
12262                                                        {
12263                                                          if (((word >> 20) & 0x1) == 0)
12264                                                            {
12265                                                              if (((word >> 30) & 0x1) == 0)
12266                                                                {
12267                                                                  /* 33222222222211111111110000000000
12268                                                                     10987654321098765432109876543210
12269                                                                     000001x0xx000111100xxxxxxxxxxxxx
12270                                                                     uqshl.  */
12271                                                                  return 2347;
12272                                                                }
12273                                                              else
12274                                                                {
12275                                                                  /* 33222222222211111111110000000000
12276                                                                     10987654321098765432109876543210
12277                                                                     010001x0xx000111100xxxxxxxxxxxxx
12278                                                                     urshlr.  */
12279                                                                  return 2359;
12280                                                                }
12281                                                            }
12282                                                          else
12283                                                            {
12284                                                              if (((word >> 30) & 0x1) == 0)
12285                                                                {
12286                                                                  /* 33222222222211111111110000000000
12287                                                                     10987654321098765432109876543210
12288                                                                     000001x0xx010111100xxxxxxxxxxxxx
12289                                                                     lslr.  */
12290                                                                  return 1786;
12291                                                                }
12292                                                              else
12293                                                                {
12294                                                                  /* 33222222222211111111110000000000
12295                                                                     10987654321098765432109876543210
12296                                                                     010001x0xx010111100xxxxxxxxxxxxx
12297                                                                     uhsubr.  */
12298                                                                  return 2320;
12299                                                                }
12300                                                            }
12301                                                        }
12302                                                      else
12303                                                        {
12304                                                          if (((word >> 20) & 0x1) == 0)
12305                                                            {
12306                                                              if (((word >> 30) & 0x1) == 0)
12307                                                                {
12308                                                                  /* 33222222222211111111110000000000
12309                                                                     10987654321098765432109876543210
12310                                                                     000001x0xx001111100xxxxxxxxxxxxx
12311                                                                     sqshlu.  */
12312                                                                  return 2270;
12313                                                                }
12314                                                              else
12315                                                                {
12316                                                                  /* 33222222222211111111110000000000
12317                                                                     10987654321098765432109876543210
12318                                                                     010001x0xx001111100xxxxxxxxxxxxx
12319                                                                     uqrshlr.  */
12320                                                                  return 2344;
12321                                                                }
12322                                                            }
12323                                                          else
12324                                                            {
12325                                                              /* 33222222222211111111110000000000
12326                                                                 10987654321098765432109876543210
12327                                                                 0x0001x0xx011111100xxxxxxxxxxxxx
12328                                                                 uqsubr.  */
12329                                                              return 2353;
12330                                                            }
12331                                                        }
12332                                                    }
12333                                                }
12334                                            }
12335                                        }
12336                                      else
12337                                        {
12338                                          if (((word >> 10) & 0x1) == 0)
12339                                            {
12340                                              if (((word >> 12) & 0x1) == 0)
12341                                                {
12342                                                  if (((word >> 30) & 0x1) == 0)
12343                                                    {
12344                                                      /* 33222222222211111111110000000000
12345                                                         10987654321098765432109876543210
12346                                                         000001x0xx1xxxxx1000x0xxxxxxxxxx
12347                                                         asr.  */
12348                                                      return 1342;
12349                                                    }
12350                                                  else
12351                                                    {
12352                                                      if (((word >> 22) & 0x1) == 0)
12353                                                        {
12354                                                          /* 33222222222211111111110000000000
12355                                                             10987654321098765432109876543210
12356                                                             010001x0x01xxxxx1000x0xxxxxxxxxx
12357                                                             smlalb.  */
12358                                                          return 2198;
12359                                                        }
12360                                                      else
12361                                                        {
12362                                                          /* 33222222222211111111110000000000
12363                                                             10987654321098765432109876543210
12364                                                             010001x0x11xxxxx1000x0xxxxxxxxxx
12365                                                             smlalb.  */
12366                                                          return 2199;
12367                                                        }
12368                                                    }
12369                                                }
12370                                              else
12371                                                {
12372                                                  if (((word >> 30) & 0x1) == 0)
12373                                                    {
12374                                                      /* 33222222222211111111110000000000
12375                                                         10987654321098765432109876543210
12376                                                         000001x0xx1xxxxx1001x0xxxxxxxxxx
12377                                                         asr.  */
12378                                                      return 1343;
12379                                                    }
12380                                                  else
12381                                                    {
12382                                                      if (((word >> 22) & 0x1) == 0)
12383                                                        {
12384                                                          /* 33222222222211111111110000000000
12385                                                             10987654321098765432109876543210
12386                                                             010001x0x01xxxxx1001x0xxxxxxxxxx
12387                                                             umlalb.  */
12388                                                          return 2323;
12389                                                        }
12390                                                      else
12391                                                        {
12392                                                          /* 33222222222211111111110000000000
12393                                                             10987654321098765432109876543210
12394                                                             010001x0x11xxxxx1001x0xxxxxxxxxx
12395                                                             umlalb.  */
12396                                                          return 2324;
12397                                                        }
12398                                                    }
12399                                                }
12400                                            }
12401                                          else
12402                                            {
12403                                              if (((word >> 12) & 0x1) == 0)
12404                                                {
12405                                                  if (((word >> 30) & 0x1) == 0)
12406                                                    {
12407                                                      if (((word >> 11) & 0x1) == 0)
12408                                                        {
12409                                                          /* 33222222222211111111110000000000
12410                                                             10987654321098765432109876543210
12411                                                             000001x0xx1xxxxx100001xxxxxxxxxx
12412                                                             lsr.  */
12413                                                          return 1787;
12414                                                        }
12415                                                      else
12416                                                        {
12417                                                          /* 33222222222211111111110000000000
12418                                                             10987654321098765432109876543210
12419                                                             000001x0xx1xxxxx100011xxxxxxxxxx
12420                                                             lsl.  */
12421                                                          return 1781;
12422                                                        }
12423                                                    }
12424                                                  else
12425                                                    {
12426                                                      if (((word >> 22) & 0x1) == 0)
12427                                                        {
12428                                                          /* 33222222222211111111110000000000
12429                                                             10987654321098765432109876543210
12430                                                             010001x0x01xxxxx1000x1xxxxxxxxxx
12431                                                             smlalt.  */
12432                                                          return 2201;
12433                                                        }
12434                                                      else
12435                                                        {
12436                                                          /* 33222222222211111111110000000000
12437                                                             10987654321098765432109876543210
12438                                                             010001x0x11xxxxx1000x1xxxxxxxxxx
12439                                                             smlalt.  */
12440                                                          return 2202;
12441                                                        }
12442                                                    }
12443                                                }
12444                                              else
12445                                                {
12446                                                  if (((word >> 30) & 0x1) == 0)
12447                                                    {
12448                                                      if (((word >> 11) & 0x1) == 0)
12449                                                        {
12450                                                          /* 33222222222211111111110000000000
12451                                                             10987654321098765432109876543210
12452                                                             000001x0xx1xxxxx100101xxxxxxxxxx
12453                                                             lsr.  */
12454                                                          return 1788;
12455                                                        }
12456                                                      else
12457                                                        {
12458                                                          /* 33222222222211111111110000000000
12459                                                             10987654321098765432109876543210
12460                                                             000001x0xx1xxxxx100111xxxxxxxxxx
12461                                                             lsl.  */
12462                                                          return 1782;
12463                                                        }
12464                                                    }
12465                                                  else
12466                                                    {
12467                                                      if (((word >> 22) & 0x1) == 0)
12468                                                        {
12469                                                          /* 33222222222211111111110000000000
12470                                                             10987654321098765432109876543210
12471                                                             010001x0x01xxxxx1001x1xxxxxxxxxx
12472                                                             umlalt.  */
12473                                                          return 2326;
12474                                                        }
12475                                                      else
12476                                                        {
12477                                                          /* 33222222222211111111110000000000
12478                                                             10987654321098765432109876543210
12479                                                             010001x0x11xxxxx1001x1xxxxxxxxxx
12480                                                             umlalt.  */
12481                                                          return 2327;
12482                                                        }
12483                                                    }
12484                                                }
12485                                            }
12486                                        }
12487                                    }
12488                                  else
12489                                    {
12490                                      if (((word >> 22) & 0x1) == 0)
12491                                        {
12492                                          if (((word >> 21) & 0x1) == 0)
12493                                            {
12494                                              if (((word >> 23) & 0x1) == 0)
12495                                                {
12496                                                  /* 33222222222211111111110000000000
12497                                                     10987654321098765432109876543210
12498                                                     1x0001x0000xxxxx100xxxxxxxxxxxxx
12499                                                     ldnt1sb.  */
12500                                                  return 2150;
12501                                                }
12502                                              else
12503                                                {
12504                                                  /* 33222222222211111111110000000000
12505                                                     10987654321098765432109876543210
12506                                                     1x0001x0100xxxxx100xxxxxxxxxxxxx
12507                                                     ldnt1sh.  */
12508                                                  return 2151;
12509                                                }
12510                                            }
12511                                          else
12512                                            {
12513                                              if (((word >> 23) & 0x1) == 0)
12514                                                {
12515                                                  if (((word >> 30) & 0x1) == 0)
12516                                                    {
12517                                                      /* 33222222222211111111110000000000
12518                                                         10987654321098765432109876543210
12519                                                         100001x0001xxxxx100xxxxxxxxxxxxx
12520                                                         ld1sb.  */
12521                                                      return 1618;
12522                                                    }
12523                                                  else
12524                                                    {
12525                                                      /* 33222222222211111111110000000000
12526                                                         10987654321098765432109876543210
12527                                                         110001x0001xxxxx100xxxxxxxxxxxxx
12528                                                         ld1sb.  */
12529                                                      return 1622;
12530                                                    }
12531                                                }
12532                                              else
12533                                                {
12534                                                  if (((word >> 30) & 0x1) == 0)
12535                                                    {
12536                                                      /* 33222222222211111111110000000000
12537                                                         10987654321098765432109876543210
12538                                                         100001x0101xxxxx100xxxxxxxxxxxxx
12539                                                         ld1sh.  */
12540                                                      return 1631;
12541                                                    }
12542                                                  else
12543                                                    {
12544                                                      /* 33222222222211111111110000000000
12545                                                         10987654321098765432109876543210
12546                                                         110001x0101xxxxx100xxxxxxxxxxxxx
12547                                                         ld1sh.  */
12548                                                      return 1634;
12549                                                    }
12550                                                }
12551                                            }
12552                                        }
12553                                      else
12554                                        {
12555                                          if (((word >> 23) & 0x1) == 0)
12556                                            {
12557                                              if (((word >> 30) & 0x1) == 0)
12558                                                {
12559                                                  /* 33222222222211111111110000000000
12560                                                     10987654321098765432109876543210
12561                                                     100001x001xxxxxx100xxxxxxxxxxxxx
12562                                                     ld1rb.  */
12563                                                  return 1588;
12564                                                }
12565                                              else
12566                                                {
12567                                                  if (((word >> 21) & 0x1) == 0)
12568                                                    {
12569                                                      /* 33222222222211111111110000000000
12570                                                         10987654321098765432109876543210
12571                                                         110001x0010xxxxx100xxxxxxxxxxxxx
12572                                                         ld1sb.  */
12573                                                      return 1617;
12574                                                    }
12575                                                  else
12576                                                    {
12577                                                      /* 33222222222211111111110000000000
12578                                                         10987654321098765432109876543210
12579                                                         110001x0011xxxxx100xxxxxxxxxxxxx
12580                                                         prfb.  */
12581                                                      return 1822;
12582                                                    }
12583                                                }
12584                                            }
12585                                          else
12586                                            {
12587                                              if (((word >> 30) & 0x1) == 0)
12588                                                {
12589                                                  /* 33222222222211111111110000000000
12590                                                     10987654321098765432109876543210
12591                                                     100001x011xxxxxx100xxxxxxxxxxxxx
12592                                                     ld1rsw.  */
12593                                                  return 1609;
12594                                                }
12595                                              else
12596                                                {
12597                                                  if (((word >> 21) & 0x1) == 0)
12598                                                    {
12599                                                      /* 33222222222211111111110000000000
12600                                                         10987654321098765432109876543210
12601                                                         110001x0110xxxxx100xxxxxxxxxxxxx
12602                                                         ld1sh.  */
12603                                                      return 1629;
12604                                                    }
12605                                                  else
12606                                                    {
12607                                                      /* 33222222222211111111110000000000
12608                                                         10987654321098765432109876543210
12609                                                         110001x0111xxxxx100xxxxxxxxxxxxx
12610                                                         ld1sh.  */
12611                                                      return 1630;
12612                                                    }
12613                                                }
12614                                            }
12615                                        }
12616                                    }
12617                                }
12618                            }
12619                          else
12620                            {
12621                              if (((word >> 15) & 0x1) == 0)
12622                                {
12623                                  if (((word >> 21) & 0x1) == 0)
12624                                    {
12625                                      if (((word >> 30) & 0x1) == 0)
12626                                        {
12627                                          if (((word >> 31) & 0x1) == 0)
12628                                            {
12629                                              /* 33222222222211111111110000000000
12630                                                 10987654321098765432109876543210
12631                                                 000001x0xx0xxxxx010xxxxxxxxxxxxx
12632                                                 mla.  */
12633                                              return 1794;
12634                                            }
12635                                          else
12636                                            {
12637                                              if (((word >> 23) & 0x1) == 0)
12638                                                {
12639                                                  /* 33222222222211111111110000000000
12640                                                     10987654321098765432109876543210
12641                                                     100001x00x0xxxxx010xxxxxxxxxxxxx
12642                                                     ld1b.  */
12643                                                  return 1554;
12644                                                }
12645                                              else
12646                                                {
12647                                                  /* 33222222222211111111110000000000
12648                                                     10987654321098765432109876543210
12649                                                     100001x01x0xxxxx010xxxxxxxxxxxxx
12650                                                     ld1h.  */
12651                                                  return 1574;
12652                                                }
12653                                            }
12654                                        }
12655                                      else
12656                                        {
12657                                          if (((word >> 31) & 0x1) == 0)
12658                                            {
12659                                              if (((word >> 10) & 0x1) == 0)
12660                                                {
12661                                                  if (((word >> 11) & 0x1) == 0)
12662                                                    {
12663                                                      if (((word >> 12) & 0x1) == 0)
12664                                                        {
12665                                                          /* 33222222222211111111110000000000
12666                                                             10987654321098765432109876543210
12667                                                             010001x0xx0xxxxx010000xxxxxxxxxx
12668                                                             smlalb.  */
12669                                                          return 2200;
12670                                                        }
12671                                                      else
12672                                                        {
12673                                                          /* 33222222222211111111110000000000
12674                                                             10987654321098765432109876543210
12675                                                             010001x0xx0xxxxx010100xxxxxxxxxx
12676                                                             smlslb.  */
12677                                                          return 2206;
12678                                                        }
12679                                                    }
12680                                                  else
12681                                                    {
12682                                                      if (((word >> 12) & 0x1) == 0)
12683                                                        {
12684                                                          /* 33222222222211111111110000000000
12685                                                             10987654321098765432109876543210
12686                                                             010001x0xx0xxxxx010010xxxxxxxxxx
12687                                                             umlalb.  */
12688                                                          return 2325;
12689                                                        }
12690                                                      else
12691                                                        {
12692                                                          /* 33222222222211111111110000000000
12693                                                             10987654321098765432109876543210
12694                                                             010001x0xx0xxxxx010110xxxxxxxxxx
12695                                                             umlslb.  */
12696                                                          return 2331;
12697                                                        }
12698                                                    }
12699                                                }
12700                                              else
12701                                                {
12702                                                  if (((word >> 11) & 0x1) == 0)
12703                                                    {
12704                                                      if (((word >> 12) & 0x1) == 0)
12705                                                        {
12706                                                          /* 33222222222211111111110000000000
12707                                                             10987654321098765432109876543210
12708                                                             010001x0xx0xxxxx010001xxxxxxxxxx
12709                                                             smlalt.  */
12710                                                          return 2203;
12711                                                        }
12712                                                      else
12713                                                        {
12714                                                          /* 33222222222211111111110000000000
12715                                                             10987654321098765432109876543210
12716                                                             010001x0xx0xxxxx010101xxxxxxxxxx
12717                                                             smlslt.  */
12718                                                          return 2209;
12719                                                        }
12720                                                    }
12721                                                  else
12722                                                    {
12723                                                      if (((word >> 12) & 0x1) == 0)
12724                                                        {
12725                                                          /* 33222222222211111111110000000000
12726                                                             10987654321098765432109876543210
12727                                                             010001x0xx0xxxxx010011xxxxxxxxxx
12728                                                             umlalt.  */
12729                                                          return 2328;
12730                                                        }
12731                                                      else
12732                                                        {
12733                                                          /* 33222222222211111111110000000000
12734                                                             10987654321098765432109876543210
12735                                                             010001x0xx0xxxxx010111xxxxxxxxxx
12736                                                             umlslt.  */
12737                                                          return 2334;
12738                                                        }
12739                                                    }
12740                                                }
12741                                            }
12742                                          else
12743                                            {
12744                                              if (((word >> 23) & 0x1) == 0)
12745                                                {
12746                                                  /* 33222222222211111111110000000000
12747                                                     10987654321098765432109876543210
12748                                                     110001x00x0xxxxx010xxxxxxxxxxxxx
12749                                                     ld1b.  */
12750                                                  return 1559;
12751                                                }
12752                                              else
12753                                                {
12754                                                  /* 33222222222211111111110000000000
12755                                                     10987654321098765432109876543210
12756                                                     110001x01x0xxxxx010xxxxxxxxxxxxx
12757                                                     ld1h.  */
12758                                                  return 1579;
12759                                                }
12760                                            }
12761                                        }
12762                                    }
12763                                  else
12764                                    {
12765                                      if (((word >> 30) & 0x1) == 0)
12766                                        {
12767                                          if (((word >> 31) & 0x1) == 0)
12768                                            {
12769                                              if (((word >> 11) & 0x1) == 0)
12770                                                {
12771                                                  if (((word >> 12) & 0x1) == 0)
12772                                                    {
12773                                                      if (((word >> 10) & 0x1) == 0)
12774                                                        {
12775                                                          /* 33222222222211111111110000000000
12776                                                             10987654321098765432109876543210
12777                                                             000001x0xx1xxxxx010000xxxxxxxxxx
12778                                                             index.  */
12779                                                          return 1545;
12780                                                        }
12781                                                      else
12782                                                        {
12783                                                          /* 33222222222211111111110000000000
12784                                                             10987654321098765432109876543210
12785                                                             000001x0xx1xxxxx010001xxxxxxxxxx
12786                                                             index.  */
12787                                                          return 1546;
12788                                                        }
12789                                                    }
12790                                                  else
12791                                                    {
12792                                                      if (((word >> 22) & 0x1) == 0)
12793                                                        {
12794                                                          if (((word >> 23) & 0x1) == 0)
12795                                                            {
12796                                                              /* 33222222222211111111110000000000
12797                                                                 10987654321098765432109876543210
12798                                                                 000001x0001xxxxx01010xxxxxxxxxxx
12799                                                                 addvl.  */
12800                                                              return 1332;
12801                                                            }
12802                                                          else
12803                                                            {
12804                                                              /* 33222222222211111111110000000000
12805                                                                 10987654321098765432109876543210
12806                                                                 000001x0101xxxxx01010xxxxxxxxxxx
12807                                                                 rdvl.  */
12808                                                              return 1856;
12809                                                            }
12810                                                        }
12811                                                      else
12812                                                        {
12813                                                          /* 33222222222211111111110000000000
12814                                                             10987654321098765432109876543210
12815                                                             000001x0x11xxxxx01010xxxxxxxxxxx
12816                                                             addpl.  */
12817                                                          return 1331;
12818                                                        }
12819                                                    }
12820                                                }
12821                                              else
12822                                                {
12823                                                  if (((word >> 12) & 0x1) == 0)
12824                                                    {
12825                                                      if (((word >> 10) & 0x1) == 0)
12826                                                        {
12827                                                          /* 33222222222211111111110000000000
12828                                                             10987654321098765432109876543210
12829                                                             000001x0xx1xxxxx010010xxxxxxxxxx
12830                                                             index.  */
12831                                                          return 1547;
12832                                                        }
12833                                                      else
12834                                                        {
12835                                                          /* 33222222222211111111110000000000
12836                                                             10987654321098765432109876543210
12837                                                             000001x0xx1xxxxx010011xxxxxxxxxx
12838                                                             index.  */
12839                                                          return 1544;
12840                                                        }
12841                                                    }
12842                                                  else
12843                                                    {
12844                                                      if (((word >> 22) & 0x1) == 0)
12845                                                        {
12846                                                          if (((word >> 23) & 0x1) == 0)
12847                                                            {
12848                                                              /* 33222222222211111111110000000000
12849                                                                 10987654321098765432109876543210
12850                                                                 000001x0001xxxxx01011xxxxxxxxxxx
12851                                                                 addsvl.  */
12852                                                              return 2397;
12853                                                            }
12854                                                          else
12855                                                            {
12856                                                              /* 33222222222211111111110000000000
12857                                                                 10987654321098765432109876543210
12858                                                                 000001x0101xxxxx01011xxxxxxxxxxx
12859                                                                 rdsvl.  */
12860                                                              return 2408;
12861                                                            }
12862                                                        }
12863                                                      else
12864                                                        {
12865                                                          /* 33222222222211111111110000000000
12866                                                             10987654321098765432109876543210
12867                                                             000001x0x11xxxxx01011xxxxxxxxxxx
12868                                                             addspl.  */
12869                                                          return 2396;
12870                                                        }
12871                                                    }
12872                                                }
12873                                            }
12874                                          else
12875                                            {
12876                                              if (((word >> 23) & 0x1) == 0)
12877                                                {
12878                                                  /* 33222222222211111111110000000000
12879                                                     10987654321098765432109876543210
12880                                                     100001x00x1xxxxx010xxxxxxxxxxxxx
12881                                                     prfw.  */
12882                                                  return 1840;
12883                                                }
12884                                              else
12885                                                {
12886                                                  /* 33222222222211111111110000000000
12887                                                     10987654321098765432109876543210
12888                                                     100001x01x1xxxxx010xxxxxxxxxxxxx
12889                                                     ld1h.  */
12890                                                  return 1575;
12891                                                }
12892                                            }
12893                                        }
12894                                      else
12895                                        {
12896                                          if (((word >> 23) & 0x1) == 0)
12897                                            {
12898                                              /* 33222222222211111111110000000000
12899                                                 10987654321098765432109876543210
12900                                                 x10001x00x1xxxxx010xxxxxxxxxxxxx
12901                                                 prfw.  */
12902                                              return 1842;
12903                                            }
12904                                          else
12905                                            {
12906                                              if (((word >> 31) & 0x1) == 0)
12907                                                {
12908                                                  if (((word >> 22) & 0x1) == 0)
12909                                                    {
12910                                                      /* 33222222222211111111110000000000
12911                                                         10987654321098765432109876543210
12912                                                         010001x0101xxxxx010xxxxxxxxxxxxx
12913                                                         cdot.  */
12914                                                      return 2115;
12915                                                    }
12916                                                  else
12917                                                    {
12918                                                      /* 33222222222211111111110000000000
12919                                                         10987654321098765432109876543210
12920                                                         010001x0111xxxxx010xxxxxxxxxxxxx
12921                                                         cdot.  */
12922                                                      return 2114;
12923                                                    }
12924                                                }
12925                                              else
12926                                                {
12927                                                  /* 33222222222211111111110000000000
12928                                                     10987654321098765432109876543210
12929                                                     110001x01x1xxxxx010xxxxxxxxxxxxx
12930                                                     ld1h.  */
12931                                                  return 1580;
12932                                                }
12933                                            }
12934                                        }
12935                                    }
12936                                }
12937                              else
12938                                {
12939                                  if (((word >> 30) & 0x1) == 0)
12940                                    {
12941                                      if (((word >> 31) & 0x1) == 0)
12942                                        {
12943                                          if (((word >> 21) & 0x1) == 0)
12944                                            {
12945                                              /* 33222222222211111111110000000000
12946                                                 10987654321098765432109876543210
12947                                                 000001x0xx0xxxxx110xxxxxxxxxxxxx
12948                                                 mad.  */
12949                                              return 1793;
12950                                            }
12951                                          else
12952                                            {
12953                                              if (((word >> 10) & 0x1) == 0)
12954                                                {
12955                                                  if (((word >> 11) & 0x1) == 0)
12956                                                    {
12957                                                      if (((word >> 20) & 0x1) == 0)
12958                                                        {
12959                                                          if (((word >> 22) & 0x1) == 0)
12960                                                            {
12961                                                              /* 33222222222211111111110000000000
12962                                                                 10987654321098765432109876543210
12963                                                                 000001x0x010xxxx110x00xxxxxxxxxx
12964                                                                 sqincw.  */
12965                                                              return 1914;
12966                                                            }
12967                                                          else
12968                                                            {
12969                                                              if (((word >> 23) & 0x1) == 0)
12970                                                                {
12971                                                                  /* 33222222222211111111110000000000
12972                                                                     10987654321098765432109876543210
12973                                                                     000001x00110xxxx110x00xxxxxxxxxx
12974                                                                     sqinch.  */
12975                                                                  return 1908;
12976                                                                }
12977                                                              else
12978                                                                {
12979                                                                  /* 33222222222211111111110000000000
12980                                                                     10987654321098765432109876543210
12981                                                                     000001x01110xxxx110x00xxxxxxxxxx
12982                                                                     sqincd.  */
12983                                                                  return 1905;
12984                                                                }
12985                                                            }
12986                                                        }
12987                                                      else
12988                                                        {
12989                                                          if (((word >> 22) & 0x1) == 0)
12990                                                            {
12991                                                              /* 33222222222211111111110000000000
12992                                                                 10987654321098765432109876543210
12993                                                                 000001x0x011xxxx110x00xxxxxxxxxx
12994                                                                 incw.  */
12995                                                              return 1542;
12996                                                            }
12997                                                          else
12998                                                            {
12999                                                              if (((word >> 23) & 0x1) == 0)
13000                                                                {
13001                                                                  /* 33222222222211111111110000000000
13002                                                                     10987654321098765432109876543210
13003                                                                     000001x00111xxxx110x00xxxxxxxxxx
13004                                                                     inch.  */
13005                                                                  return 1538;
13006                                                                }
13007                                                              else
13008                                                                {
13009                                                                  /* 33222222222211111111110000000000
13010                                                                     10987654321098765432109876543210
13011                                                                     000001x01111xxxx110x00xxxxxxxxxx
13012                                                                     incd.  */
13013                                                                  return 1536;
13014                                                                }
13015                                                            }
13016                                                        }
13017                                                    }
13018                                                  else
13019                                                    {
13020                                                      if (((word >> 22) & 0x1) == 0)
13021                                                        {
13022                                                          /* 33222222222211111111110000000000
13023                                                             10987654321098765432109876543210
13024                                                             000001x0x01xxxxx110x10xxxxxxxxxx
13025                                                             sqdecw.  */
13026                                                          return 1900;
13027                                                        }
13028                                                      else
13029                                                        {
13030                                                          if (((word >> 23) & 0x1) == 0)
13031                                                            {
13032                                                              /* 33222222222211111111110000000000
13033                                                                 10987654321098765432109876543210
13034                                                                 000001x0011xxxxx110x10xxxxxxxxxx
13035                                                                 sqdech.  */
13036                                                              return 1894;
13037                                                            }
13038                                                          else
13039                                                            {
13040                                                              /* 33222222222211111111110000000000
13041                                                                 10987654321098765432109876543210
13042                                                                 000001x0111xxxxx110x10xxxxxxxxxx
13043                                                                 sqdecd.  */
13044                                                              return 1891;
13045                                                            }
13046                                                        }
13047                                                    }
13048                                                }
13049                                              else
13050                                                {
13051                                                  if (((word >> 11) & 0x1) == 0)
13052                                                    {
13053                                                      if (((word >> 20) & 0x1) == 0)
13054                                                        {
13055                                                          if (((word >> 22) & 0x1) == 0)
13056                                                            {
13057                                                              /* 33222222222211111111110000000000
13058                                                                 10987654321098765432109876543210
13059                                                                 000001x0x010xxxx110x01xxxxxxxxxx
13060                                                                 uqincw.  */
13061                                                              return 2063;
13062                                                            }
13063                                                          else
13064                                                            {
13065                                                              if (((word >> 23) & 0x1) == 0)
13066                                                                {
13067                                                                  /* 33222222222211111111110000000000
13068                                                                     10987654321098765432109876543210
13069                                                                     000001x00110xxxx110x01xxxxxxxxxx
13070                                                                     uqinch.  */
13071                                                                  return 2057;
13072                                                                }
13073                                                              else
13074                                                                {
13075                                                                  /* 33222222222211111111110000000000
13076                                                                     10987654321098765432109876543210
13077                                                                     000001x01110xxxx110x01xxxxxxxxxx
13078                                                                     uqincd.  */
13079                                                                  return 2054;
13080                                                                }
13081                                                            }
13082                                                        }
13083                                                      else
13084                                                        {
13085                                                          if (((word >> 22) & 0x1) == 0)
13086                                                            {
13087                                                              /* 33222222222211111111110000000000
13088                                                                 10987654321098765432109876543210
13089                                                                 000001x0x011xxxx110x01xxxxxxxxxx
13090                                                                 decw.  */
13091                                                              return 1417;
13092                                                            }
13093                                                          else
13094                                                            {
13095                                                              if (((word >> 23) & 0x1) == 0)
13096                                                                {
13097                                                                  /* 33222222222211111111110000000000
13098                                                                     10987654321098765432109876543210
13099                                                                     000001x00111xxxx110x01xxxxxxxxxx
13100                                                                     dech.  */
13101                                                                  return 1413;
13102                                                                }
13103                                                              else
13104                                                                {
13105                                                                  /* 33222222222211111111110000000000
13106                                                                     10987654321098765432109876543210
13107                                                                     000001x01111xxxx110x01xxxxxxxxxx
13108                                                                     decd.  */
13109                                                                  return 1411;
13110                                                                }
13111                                                            }
13112                                                        }
13113                                                    }
13114                                                  else
13115                                                    {
13116                                                      if (((word >> 22) & 0x1) == 0)
13117                                                        {
13118                                                          /* 33222222222211111111110000000000
13119                                                             10987654321098765432109876543210
13120                                                             000001x0x01xxxxx110x11xxxxxxxxxx
13121                                                             uqdecw.  */
13122                                                          return 2049;
13123                                                        }
13124                                                      else
13125                                                        {
13126                                                          if (((word >> 23) & 0x1) == 0)
13127                                                            {
13128                                                              /* 33222222222211111111110000000000
13129                                                                 10987654321098765432109876543210
13130                                                                 000001x0011xxxxx110x11xxxxxxxxxx
13131                                                                 uqdech.  */
13132                                                              return 2043;
13133                                                            }
13134                                                          else
13135                                                            {
13136                                                              /* 33222222222211111111110000000000
13137                                                                 10987654321098765432109876543210
13138                                                                 000001x0111xxxxx110x11xxxxxxxxxx
13139                                                                 uqdecd.  */
13140                                                              return 2040;
13141                                                            }
13142                                                        }
13143                                                    }
13144                                                }
13145                                            }
13146                                        }
13147                                      else
13148                                        {
13149                                          if (((word >> 22) & 0x1) == 0)
13150                                            {
13151                                              if (((word >> 21) & 0x1) == 0)
13152                                                {
13153                                                  if (((word >> 23) & 0x1) == 0)
13154                                                    {
13155                                                      /* 33222222222211111111110000000000
13156                                                         10987654321098765432109876543210
13157                                                         100001x0000xxxxx110xxxxxxxxxxxxx
13158                                                         prfb.  */
13159                                                      return 1819;
13160                                                    }
13161                                                  else
13162                                                    {
13163                                                      /* 33222222222211111111110000000000
13164                                                         10987654321098765432109876543210
13165                                                         100001x0100xxxxx110xxxxxxxxxxxxx
13166                                                         prfh.  */
13167                                                      return 1834;
13168                                                    }
13169                                                }
13170                                              else
13171                                                {
13172                                                  if (((word >> 23) & 0x1) == 0)
13173                                                    {
13174                                                      /* 33222222222211111111110000000000
13175                                                         10987654321098765432109876543210
13176                                                         100001x0001xxxxx110xxxxxxxxxxxxx
13177                                                         ld1b.  */
13178                                                      return 1561;
13179                                                    }
13180                                                  else
13181                                                    {
13182                                                      /* 33222222222211111111110000000000
13183                                                         10987654321098765432109876543210
13184                                                         100001x0101xxxxx110xxxxxxxxxxxxx
13185                                                         ld1h.  */
13186                                                      return 1583;
13187                                                    }
13188                                                }
13189                                            }
13190                                          else
13191                                            {
13192                                              if (((word >> 23) & 0x1) == 0)
13193                                                {
13194                                                  /* 33222222222211111111110000000000
13195                                                     10987654321098765432109876543210
13196                                                     100001x001xxxxxx110xxxxxxxxxxxxx
13197                                                     ld1rb.  */
13198                                                  return 1590;
13199                                                }
13200                                              else
13201                                                {
13202                                                  /* 33222222222211111111110000000000
13203                                                     10987654321098765432109876543210
13204                                                     100001x011xxxxxx110xxxxxxxxxxxxx
13205                                                     ld1rh.  */
13206                                                  return 1594;
13207                                                }
13208                                            }
13209                                        }
13210                                    }
13211                                  else
13212                                    {
13213                                      if (((word >> 21) & 0x1) == 0)
13214                                        {
13215                                          if (((word >> 31) & 0x1) == 0)
13216                                            {
13217                                              if (((word >> 10) & 0x1) == 0)
13218                                                {
13219                                                  if (((word >> 11) & 0x1) == 0)
13220                                                    {
13221                                                      /* 33222222222211111111110000000000
13222                                                         10987654321098765432109876543210
13223                                                         010001x0xx0xxxxx110x00xxxxxxxxxx
13224                                                         sclamp.  */
13225                                                      return 2453;
13226                                                    }
13227                                                  else
13228                                                    {
13229                                                      if (((word >> 23) & 0x1) == 0)
13230                                                        {
13231                                                          /* 33222222222211111111110000000000
13232                                                             10987654321098765432109876543210
13233                                                             010001x00x0xxxxx110x10xxxxxxxxxx
13234                                                             sdot.  */
13235                                                          return 2466;
13236                                                        }
13237                                                      else
13238                                                        {
13239                                                          /* 33222222222211111111110000000000
13240                                                             10987654321098765432109876543210
13241                                                             010001x01x0xxxxx110x10xxxxxxxxxx
13242                                                             sdot.  */
13243                                                          return 2465;
13244                                                        }
13245                                                    }
13246                                                }
13247                                              else
13248                                                {
13249                                                  if (((word >> 11) & 0x1) == 0)
13250                                                    {
13251                                                      /* 33222222222211111111110000000000
13252                                                         10987654321098765432109876543210
13253                                                         010001x0xx0xxxxx110x01xxxxxxxxxx
13254                                                         uclamp.  */
13255                                                      return 2454;
13256                                                    }
13257                                                  else
13258                                                    {
13259                                                      if (((word >> 23) & 0x1) == 0)
13260                                                        {
13261                                                          /* 33222222222211111111110000000000
13262                                                             10987654321098765432109876543210
13263                                                             010001x00x0xxxxx110x11xxxxxxxxxx
13264                                                             udot.  */
13265                                                          return 2472;
13266                                                        }
13267                                                      else
13268                                                        {
13269                                                          /* 33222222222211111111110000000000
13270                                                             10987654321098765432109876543210
13271                                                             010001x01x0xxxxx110x11xxxxxxxxxx
13272                                                             udot.  */
13273                                                          return 2471;
13274                                                        }
13275                                                    }
13276                                                }
13277                                            }
13278                                          else
13279                                            {
13280                                              if (((word >> 22) & 0x1) == 0)
13281                                                {
13282                                                  if (((word >> 23) & 0x1) == 0)
13283                                                    {
13284                                                      /* 33222222222211111111110000000000
13285                                                         10987654321098765432109876543210
13286                                                         110001x0000xxxxx110xxxxxxxxxxxxx
13287                                                         ldnt1b.  */
13288                                                      return 2146;
13289                                                    }
13290                                                  else
13291                                                    {
13292                                                      /* 33222222222211111111110000000000
13293                                                         10987654321098765432109876543210
13294                                                         110001x0100xxxxx110xxxxxxxxxxxxx
13295                                                         ldnt1h.  */
13296                                                      return 2149;
13297                                                    }
13298                                                }
13299                                              else
13300                                                {
13301                                                  if (((word >> 23) & 0x1) == 0)
13302                                                    {
13303                                                      /* 33222222222211111111110000000000
13304                                                         10987654321098765432109876543210
13305                                                         110001x0010xxxxx110xxxxxxxxxxxxx
13306                                                         ld1b.  */
13307                                                      return 1560;
13308                                                    }
13309                                                  else
13310                                                    {
13311                                                      /* 33222222222211111111110000000000
13312                                                         10987654321098765432109876543210
13313                                                         110001x0110xxxxx110xxxxxxxxxxxxx
13314                                                         ld1h.  */
13315                                                      return 1581;
13316                                                    }
13317                                                }
13318                                            }
13319                                        }
13320                                      else
13321                                        {
13322                                          if (((word >> 22) & 0x1) == 0)
13323                                            {
13324                                              if (((word >> 23) & 0x1) == 0)
13325                                                {
13326                                                  /* 33222222222211111111110000000000
13327                                                     10987654321098765432109876543210
13328                                                     x10001x0001xxxxx110xxxxxxxxxxxxx
13329                                                     ld1b.  */
13330                                                  return 1566;
13331                                                }
13332                                              else
13333                                                {
13334                                                  if (((word >> 31) & 0x1) == 0)
13335                                                    {
13336                                                      if (((word >> 10) & 0x1) == 0)
13337                                                        {
13338                                                          if (((word >> 12) & 0x1) == 0)
13339                                                            {
13340                                                              /* 33222222222211111111110000000000
13341                                                                 10987654321098765432109876543210
13342                                                                 010001x0101xxxxx1100x0xxxxxxxxxx
13343                                                                 smullb.  */
13344                                                              return 2211;
13345                                                            }
13346                                                          else
13347                                                            {
13348                                                              /* 33222222222211111111110000000000
13349                                                                 10987654321098765432109876543210
13350                                                                 010001x0101xxxxx1101x0xxxxxxxxxx
13351                                                                 umullb.  */
13352                                                              return 2336;
13353                                                            }
13354                                                        }
13355                                                      else
13356                                                        {
13357                                                          if (((word >> 12) & 0x1) == 0)
13358                                                            {
13359                                                              /* 33222222222211111111110000000000
13360                                                                 10987654321098765432109876543210
13361                                                                 010001x0101xxxxx1100x1xxxxxxxxxx
13362                                                                 smullt.  */
13363                                                              return 2214;
13364                                                            }
13365                                                          else
13366                                                            {
13367                                                              /* 33222222222211111111110000000000
13368                                                                 10987654321098765432109876543210
13369                                                                 010001x0101xxxxx1101x1xxxxxxxxxx
13370                                                                 umullt.  */
13371                                                              return 2339;
13372                                                            }
13373                                                        }
13374                                                    }
13375                                                  else
13376                                                    {
13377                                                      /* 33222222222211111111110000000000
13378                                                         10987654321098765432109876543210
13379                                                         110001x0101xxxxx110xxxxxxxxxxxxx
13380                                                         ld1h.  */
13381                                                      return 1587;
13382                                                    }
13383                                                }
13384                                            }
13385                                          else
13386                                            {
13387                                              if (((word >> 23) & 0x1) == 0)
13388                                                {
13389                                                  /* 33222222222211111111110000000000
13390                                                     10987654321098765432109876543210
13391                                                     x10001x0011xxxxx110xxxxxxxxxxxxx
13392                                                     prfw.  */
13393                                                  return 1843;
13394                                                }
13395                                              else
13396                                                {
13397                                                  if (((word >> 31) & 0x1) == 0)
13398                                                    {
13399                                                      if (((word >> 10) & 0x1) == 0)
13400                                                        {
13401                                                          if (((word >> 12) & 0x1) == 0)
13402                                                            {
13403                                                              /* 33222222222211111111110000000000
13404                                                                 10987654321098765432109876543210
13405                                                                 010001x0111xxxxx1100x0xxxxxxxxxx
13406                                                                 smullb.  */
13407                                                              return 2212;
13408                                                            }
13409                                                          else
13410                                                            {
13411                                                              /* 33222222222211111111110000000000
13412                                                                 10987654321098765432109876543210
13413                                                                 010001x0111xxxxx1101x0xxxxxxxxxx
13414                                                                 umullb.  */
13415                                                              return 2337;
13416                                                            }
13417                                                        }
13418                                                      else
13419                                                        {
13420                                                          if (((word >> 12) & 0x1) == 0)
13421                                                            {
13422                                                              /* 33222222222211111111110000000000
13423                                                                 10987654321098765432109876543210
13424                                                                 010001x0111xxxxx1100x1xxxxxxxxxx
13425                                                                 smullt.  */
13426                                                              return 2215;
13427                                                            }
13428                                                          else
13429                                                            {
13430                                                              /* 33222222222211111111110000000000
13431                                                                 10987654321098765432109876543210
13432                                                                 010001x0111xxxxx1101x1xxxxxxxxxx
13433                                                                 umullt.  */
13434                                                              return 2340;
13435                                                            }
13436                                                        }
13437                                                    }
13438                                                  else
13439                                                    {
13440                                                      /* 33222222222211111111110000000000
13441                                                         10987654321098765432109876543210
13442                                                         110001x0111xxxxx110xxxxxxxxxxxxx
13443                                                         ld1h.  */
13444                                                      return 1582;
13445                                                    }
13446                                                }
13447                                            }
13448                                        }
13449                                    }
13450                                }
13451                            }
13452                        }
13453                      else
13454                        {
13455                          if (((word >> 14) & 0x1) == 0)
13456                            {
13457                              if (((word >> 15) & 0x1) == 0)
13458                                {
13459                                  if (((word >> 21) & 0x1) == 0)
13460                                    {
13461                                      if (((word >> 30) & 0x1) == 0)
13462                                        {
13463                                          if (((word >> 31) & 0x1) == 0)
13464                                            {
13465                                              if (((word >> 17) & 0x1) == 0)
13466                                                {
13467                                                  if (((word >> 18) & 0x1) == 0)
13468                                                    {
13469                                                      if (((word >> 19) & 0x1) == 0)
13470                                                        {
13471                                                          if (((word >> 20) & 0x1) == 0)
13472                                                            {
13473                                                              if (((word >> 16) & 0x1) == 0)
13474                                                                {
13475                                                                  /* 33222222222211111111110000000000
13476                                                                     10987654321098765432109876543210
13477                                                                     000001x0xx000000001xxxxxxxxxxxxx
13478                                                                     saddv.  */
13479                                                                  return 1863;
13480                                                                }
13481                                                              else
13482                                                                {
13483                                                                  /* 33222222222211111111110000000000
13484                                                                     10987654321098765432109876543210
13485                                                                     000001x0xx000001001xxxxxxxxxxxxx
13486                                                                     uaddv.  */
13487                                                                  return 2016;
13488                                                                }
13489                                                            }
13490                                                          else
13491                                                            {
13492                                                              /* 33222222222211111111110000000000
13493                                                                 10987654321098765432109876543210
13494                                                                 000001x0xx01000x001xxxxxxxxxxxxx
13495                                                                 movprfx.  */
13496                                                              return 1797;
13497                                                            }
13498                                                        }
13499                                                      else
13500                                                        {
13501                                                          if (((word >> 16) & 0x1) == 0)
13502                                                            {
13503                                                              if (((word >> 20) & 0x1) == 0)
13504                                                                {
13505                                                                  /* 33222222222211111111110000000000
13506                                                                     10987654321098765432109876543210
13507                                                                     000001x0xx001000001xxxxxxxxxxxxx
13508                                                                     smaxv.  */
13509                                                                  return 1881;
13510                                                                }
13511                                                              else
13512                                                                {
13513                                                                  /* 33222222222211111111110000000000
13514                                                                     10987654321098765432109876543210
13515                                                                     000001x0xx011000001xxxxxxxxxxxxx
13516                                                                     orv.  */
13517                                                                  return 1814;
13518                                                                }
13519                                                            }
13520                                                          else
13521                                                            {
13522                                                              if (((word >> 20) & 0x1) == 0)
13523                                                                {
13524                                                                  /* 33222222222211111111110000000000
13525                                                                     10987654321098765432109876543210
13526                                                                     000001x0xx001001001xxxxxxxxxxxxx
13527                                                                     umaxv.  */
13528                                                                  return 2031;
13529                                                                }
13530                                                              else
13531                                                                {
13532                                                                  /* 33222222222211111111110000000000
13533                                                                     10987654321098765432109876543210
13534                                                                     000001x0xx011001001xxxxxxxxxxxxx
13535                                                                     eorv.  */
13536                                                                  return 1428;
13537                                                                }
13538                                                            }
13539                                                        }
13540                                                    }
13541                                                  else
13542                                                    {
13543                                                      if (((word >> 16) & 0x1) == 0)
13544                                                        {
13545                                                          /* 33222222222211111111110000000000
13546                                                             10987654321098765432109876543210
13547                                                             000001x0xx0xx100001xxxxxxxxxxxxx
13548                                                             smaxqv.  */
13549                                                          return 3297;
13550                                                        }
13551                                                      else
13552                                                        {
13553                                                          if (((word >> 19) & 0x1) == 0)
13554                                                            {
13555                                                              /* 33222222222211111111110000000000
13556                                                                 10987654321098765432109876543210
13557                                                                 000001x0xx0x0101001xxxxxxxxxxxxx
13558                                                                 addqv.  */
13559                                                              return 3295;
13560                                                            }
13561                                                          else
13562                                                            {
13563                                                              if (((word >> 20) & 0x1) == 0)
13564                                                                {
13565                                                                  /* 33222222222211111111110000000000
13566                                                                     10987654321098765432109876543210
13567                                                                     000001x0xx001101001xxxxxxxxxxxxx
13568                                                                     umaxqv.  */
13569                                                                  return 3299;
13570                                                                }
13571                                                              else
13572                                                                {
13573                                                                  /* 33222222222211111111110000000000
13574                                                                     10987654321098765432109876543210
13575                                                                     000001x0xx011101001xxxxxxxxxxxxx
13576                                                                     eorqv.  */
13577                                                                  return 3301;
13578                                                                }
13579                                                            }
13580                                                        }
13581                                                    }
13582                                                }
13583                                              else
13584                                                {
13585                                                  if (((word >> 16) & 0x1) == 0)
13586                                                    {
13587                                                      if (((word >> 18) & 0x1) == 0)
13588                                                        {
13589                                                          if (((word >> 20) & 0x1) == 0)
13590                                                            {
13591                                                              /* 33222222222211111111110000000000
13592                                                                 10987654321098765432109876543210
13593                                                                 000001x0xx00x010001xxxxxxxxxxxxx
13594                                                                 sminv.  */
13595                                                              return 1884;
13596                                                            }
13597                                                          else
13598                                                            {
13599                                                              /* 33222222222211111111110000000000
13600                                                                 10987654321098765432109876543210
13601                                                                 000001x0xx01x010001xxxxxxxxxxxxx
13602                                                                 andv.  */
13603                                                              return 1341;
13604                                                            }
13605                                                        }
13606                                                      else
13607                                                        {
13608                                                          if (((word >> 20) & 0x1) == 0)
13609                                                            {
13610                                                              /* 33222222222211111111110000000000
13611                                                                 10987654321098765432109876543210
13612                                                                 000001x0xx00x110001xxxxxxxxxxxxx
13613                                                                 sminqv.  */
13614                                                              return 3298;
13615                                                            }
13616                                                          else
13617                                                            {
13618                                                              /* 33222222222211111111110000000000
13619                                                                 10987654321098765432109876543210
13620                                                                 000001x0xx01x110001xxxxxxxxxxxxx
13621                                                                 andqv.  */
13622                                                              return 3296;
13623                                                            }
13624                                                        }
13625                                                    }
13626                                                  else
13627                                                    {
13628                                                      if (((word >> 18) & 0x1) == 0)
13629                                                        {
13630                                                          /* 33222222222211111111110000000000
13631                                                             10987654321098765432109876543210
13632                                                             000001x0xx0xx011001xxxxxxxxxxxxx
13633                                                             uminv.  */
13634                                                          return 2034;
13635                                                        }
13636                                                      else
13637                                                        {
13638                                                          /* 33222222222211111111110000000000
13639                                                             10987654321098765432109876543210
13640                                                             000001x0xx0xx111001xxxxxxxxxxxxx
13641                                                             uminqv.  */
13642                                                          return 3300;
13643                                                        }
13644                                                    }
13645                                                }
13646                                            }
13647                                          else
13648                                            {
13649                                              if (((word >> 23) & 0x1) == 0)
13650                                                {
13651                                                  /* 33222222222211111111110000000000
13652                                                     10987654321098765432109876543210
13653                                                     100001x00x0xxxxx001xxxxxxxxxxxxx
13654                                                     ldff1sb.  */
13655                                                  return 1712;
13656                                                }
13657                                              else
13658                                                {
13659                                                  /* 33222222222211111111110000000000
13660                                                     10987654321098765432109876543210
13661                                                     100001x01x0xxxxx001xxxxxxxxxxxxx
13662                                                     ldff1sh.  */
13663                                                  return 1723;
13664                                                }
13665                                            }
13666                                        }
13667                                      else
13668                                        {
13669                                          if (((word >> 31) & 0x1) == 0)
13670                                            {
13671                                              if (((word >> 12) & 0x1) == 0)
13672                                                {
13673                                                  /* 33222222222211111111110000000000
13674                                                     10987654321098765432109876543210
13675                                                     010001x0xx0xxxxx0010xxxxxxxxxxxx
13676                                                     cmla.  */
13677                                                  return 2116;
13678                                                }
13679                                              else
13680                                                {
13681                                                  /* 33222222222211111111110000000000
13682                                                     10987654321098765432109876543210
13683                                                     010001x0xx0xxxxx0011xxxxxxxxxxxx
13684                                                     sqrdcmlah.  */
13685                                                  return 2248;
13686                                                }
13687                                            }
13688                                          else
13689                                            {
13690                                              if (((word >> 23) & 0x1) == 0)
13691                                                {
13692                                                  /* 33222222222211111111110000000000
13693                                                     10987654321098765432109876543210
13694                                                     110001x00x0xxxxx001xxxxxxxxxxxxx
13695                                                     ldff1sb.  */
13696                                                  return 1719;
13697                                                }
13698                                              else
13699                                                {
13700                                                  /* 33222222222211111111110000000000
13701                                                     10987654321098765432109876543210
13702                                                     110001x01x0xxxxx001xxxxxxxxxxxxx
13703                                                     ldff1sh.  */
13704                                                  return 1729;
13705                                                }
13706                                            }
13707                                        }
13708                                    }
13709                                  else
13710                                    {
13711                                      if (((word >> 30) & 0x1) == 0)
13712                                        {
13713                                          if (((word >> 31) & 0x1) == 0)
13714                                            {
13715                                              if (((word >> 10) & 0x1) == 0)
13716                                                {
13717                                                  if (((word >> 11) & 0x1) == 0)
13718                                                    {
13719                                                      if (((word >> 22) & 0x1) == 0)
13720                                                        {
13721                                                          if (((word >> 23) & 0x1) == 0)
13722                                                            {
13723                                                              /* 33222222222211111111110000000000
13724                                                                 10987654321098765432109876543210
13725                                                                 000001x0001xxxxx001x00xxxxxxxxxx
13726                                                                 and.  */
13727                                                              return 1336;
13728                                                            }
13729                                                          else
13730                                                            {
13731                                                              /* 33222222222211111111110000000000
13732                                                                 10987654321098765432109876543210
13733                                                                 000001x0101xxxxx001x00xxxxxxxxxx
13734                                                                 eor.  */
13735                                                              return 1423;
13736                                                            }
13737                                                        }
13738                                                      else
13739                                                        {
13740                                                          if (((word >> 23) & 0x1) == 0)
13741                                                            {
13742                                                              /* 33222222222211111111110000000000
13743                                                                 10987654321098765432109876543210
13744                                                                 000001x0011xxxxx001x00xxxxxxxxxx
13745                                                                 orr.  */
13746                                                              return 1809;
13747                                                            }
13748                                                          else
13749                                                            {
13750                                                              /* 33222222222211111111110000000000
13751                                                                 10987654321098765432109876543210
13752                                                                 000001x0111xxxxx001x00xxxxxxxxxx
13753                                                                 bic.  */
13754                                                              return 1349;
13755                                                            }
13756                                                        }
13757                                                    }
13758                                                  else
13759                                                    {
13760                                                      if (((word >> 22) & 0x1) == 0)
13761                                                        {
13762                                                          /* 33222222222211111111110000000000
13763                                                             10987654321098765432109876543210
13764                                                             000001x0x01xxxxx001x10xxxxxxxxxx
13765                                                             eor3.  */
13766                                                          return 2119;
13767                                                        }
13768                                                      else
13769                                                        {
13770                                                          /* 33222222222211111111110000000000
13771                                                             10987654321098765432109876543210
13772                                                             000001x0x11xxxxx001x10xxxxxxxxxx
13773                                                             bcax.  */
13774                                                          return 2108;
13775                                                        }
13776                                                    }
13777                                                }
13778                                              else
13779                                                {
13780                                                  if (((word >> 11) & 0x1) == 0)
13781                                                    {
13782                                                      /* 33222222222211111111110000000000
13783                                                         10987654321098765432109876543210
13784                                                         000001x0xx1xxxxx001x01xxxxxxxxxx
13785                                                         xar.  */
13786                                                      return 2381;
13787                                                    }
13788                                                  else
13789                                                    {
13790                                                      if (((word >> 22) & 0x1) == 0)
13791                                                        {
13792                                                          if (((word >> 23) & 0x1) == 0)
13793                                                            {
13794                                                              /* 33222222222211111111110000000000
13795                                                                 10987654321098765432109876543210
13796                                                                 000001x0001xxxxx001x11xxxxxxxxxx
13797                                                                 bsl.  */
13798                                                              return 2109;
13799                                                            }
13800                                                          else
13801                                                            {
13802                                                              /* 33222222222211111111110000000000
13803                                                                 10987654321098765432109876543210
13804                                                                 000001x0101xxxxx001x11xxxxxxxxxx
13805                                                                 bsl2n.  */
13806                                                              return 2111;
13807                                                            }
13808                                                        }
13809                                                      else
13810                                                        {
13811                                                          if (((word >> 23) & 0x1) == 0)
13812                                                            {
13813                                                              /* 33222222222211111111110000000000
13814                                                                 10987654321098765432109876543210
13815                                                                 000001x0011xxxxx001x11xxxxxxxxxx
13816                                                                 bsl1n.  */
13817                                                              return 2110;
13818                                                            }
13819                                                          else
13820                                                            {
13821                                                              /* 33222222222211111111110000000000
13822                                                                 10987654321098765432109876543210
13823                                                                 000001x0111xxxxx001x11xxxxxxxxxx
13824                                                                 nbsl.  */
13825                                                              return 2166;
13826                                                            }
13827                                                        }
13828                                                    }
13829                                                }
13830                                            }
13831                                          else
13832                                            {
13833                                              if (((word >> 23) & 0x1) == 0)
13834                                                {
13835                                                  /* 33222222222211111111110000000000
13836                                                     10987654321098765432109876543210
13837                                                     100001x00x1xxxxx001xxxxxxxxxxxxx
13838                                                     prfh.  */
13839                                                  return 1833;
13840                                                }
13841                                              else
13842                                                {
13843                                                  /* 33222222222211111111110000000000
13844                                                     10987654321098765432109876543210
13845                                                     100001x01x1xxxxx001xxxxxxxxxxxxx
13846                                                     ldff1sh.  */
13847                                                  return 1724;
13848                                                }
13849                                            }
13850                                        }
13851                                      else
13852                                        {
13853                                          if (((word >> 23) & 0x1) == 0)
13854                                            {
13855                                              /* 33222222222211111111110000000000
13856                                                 10987654321098765432109876543210
13857                                                 x10001x00x1xxxxx001xxxxxxxxxxxxx
13858                                                 prfh.  */
13859                                              return 1835;
13860                                            }
13861                                          else
13862                                            {
13863                                              if (((word >> 31) & 0x1) == 0)
13864                                                {
13865                                                  if (((word >> 10) & 0x1) == 0)
13866                                                    {
13867                                                      if (((word >> 12) & 0x1) == 0)
13868                                                        {
13869                                                          if (((word >> 22) & 0x1) == 0)
13870                                                            {
13871                                                              /* 33222222222211111111110000000000
13872                                                                 10987654321098765432109876543210
13873                                                                 010001x0101xxxxx0010x0xxxxxxxxxx
13874                                                                 sqdmlalb.  */
13875                                                              return 2221;
13876                                                            }
13877                                                          else
13878                                                            {
13879                                                              /* 33222222222211111111110000000000
13880                                                                 10987654321098765432109876543210
13881                                                                 010001x0111xxxxx0010x0xxxxxxxxxx
13882                                                                 sqdmlalb.  */
13883                                                              return 2222;
13884                                                            }
13885                                                        }
13886                                                      else
13887                                                        {
13888                                                          if (((word >> 22) & 0x1) == 0)
13889                                                            {
13890                                                              /* 33222222222211111111110000000000
13891                                                                 10987654321098765432109876543210
13892                                                                 010001x0101xxxxx0011x0xxxxxxxxxx
13893                                                                 sqdmlslb.  */
13894                                                              return 2228;
13895                                                            }
13896                                                          else
13897                                                            {
13898                                                              /* 33222222222211111111110000000000
13899                                                                 10987654321098765432109876543210
13900                                                                 010001x0111xxxxx0011x0xxxxxxxxxx
13901                                                                 sqdmlslb.  */
13902                                                              return 2229;
13903                                                            }
13904                                                        }
13905                                                    }
13906                                                  else
13907                                                    {
13908                                                      if (((word >> 12) & 0x1) == 0)
13909                                                        {
13910                                                          if (((word >> 22) & 0x1) == 0)
13911                                                            {
13912                                                              /* 33222222222211111111110000000000
13913                                                                 10987654321098765432109876543210
13914                                                                 010001x0101xxxxx0010x1xxxxxxxxxx
13915                                                                 sqdmlalt.  */
13916                                                              return 2225;
13917                                                            }
13918                                                          else
13919                                                            {
13920                                                              /* 33222222222211111111110000000000
13921                                                                 10987654321098765432109876543210
13922                                                                 010001x0111xxxxx0010x1xxxxxxxxxx
13923                                                                 sqdmlalt.  */
13924                                                              return 2226;
13925                                                            }
13926                                                        }
13927                                                      else
13928                                                        {
13929                                                          if (((word >> 22) & 0x1) == 0)
13930                                                            {
13931                                                              /* 33222222222211111111110000000000
13932                                                                 10987654321098765432109876543210
13933                                                                 010001x0101xxxxx0011x1xxxxxxxxxx
13934                                                                 sqdmlslt.  */
13935                                                              return 2232;
13936                                                            }
13937                                                          else
13938                                                            {
13939                                                              /* 33222222222211111111110000000000
13940                                                                 10987654321098765432109876543210
13941                                                                 010001x0111xxxxx0011x1xxxxxxxxxx
13942                                                                 sqdmlslt.  */
13943                                                              return 2233;
13944                                                            }
13945                                                        }
13946                                                    }
13947                                                }
13948                                              else
13949                                                {
13950                                                  /* 33222222222211111111110000000000
13951                                                     10987654321098765432109876543210
13952                                                     110001x01x1xxxxx001xxxxxxxxxxxxx
13953                                                     ldff1sh.  */
13954                                                  return 1730;
13955                                                }
13956                                            }
13957                                        }
13958                                    }
13959                                }
13960                              else
13961                                {
13962                                  if (((word >> 30) & 0x1) == 0)
13963                                    {
13964                                      if (((word >> 31) & 0x1) == 0)
13965                                        {
13966                                          if (((word >> 21) & 0x1) == 0)
13967                                            {
13968                                              if (((word >> 16) & 0x1) == 0)
13969                                                {
13970                                                  if (((word >> 17) & 0x1) == 0)
13971                                                    {
13972                                                      if (((word >> 18) & 0x1) == 0)
13973                                                        {
13974                                                          if (((word >> 19) & 0x1) == 0)
13975                                                            {
13976                                                              /* 33222222222211111111110000000000
13977                                                                 10987654321098765432109876543210
13978                                                                 000001x0xx0x0000101xxxxxxxxxxxxx
13979                                                                 sxtb.  */
13980                                                              return 2007;
13981                                                            }
13982                                                          else
13983                                                            {
13984                                                              /* 33222222222211111111110000000000
13985                                                                 10987654321098765432109876543210
13986                                                                 000001x0xx0x1000101xxxxxxxxxxxxx
13987                                                                 cls.  */
13988                                                              return 1369;
13989                                                            }
13990                                                        }
13991                                                      else
13992                                                        {
13993                                                          if (((word >> 19) & 0x1) == 0)
13994                                                            {
13995                                                              /* 33222222222211111111110000000000
13996                                                                 10987654321098765432109876543210
13997                                                                 000001x0xx0x0100101xxxxxxxxxxxxx
13998                                                                 sxtw.  */
13999                                                              return 2009;
14000                                                            }
14001                                                          else
14002                                                            {
14003                                                              /* 33222222222211111111110000000000
14004                                                                 10987654321098765432109876543210
14005                                                                 000001x0xx0x1100101xxxxxxxxxxxxx
14006                                                                 fabs.  */
14007                                                              return 1431;
14008                                                            }
14009                                                        }
14010                                                    }
14011                                                  else
14012                                                    {
14013                                                      if (((word >> 18) & 0x1) == 0)
14014                                                        {
14015                                                          if (((word >> 19) & 0x1) == 0)
14016                                                            {
14017                                                              /* 33222222222211111111110000000000
14018                                                                 10987654321098765432109876543210
14019                                                                 000001x0xx0x0010101xxxxxxxxxxxxx
14020                                                                 sxth.  */
14021                                                              return 2008;
14022                                                            }
14023                                                          else
14024                                                            {
14025                                                              /* 33222222222211111111110000000000
14026                                                                 10987654321098765432109876543210
14027                                                                 000001x0xx0x1010101xxxxxxxxxxxxx
14028                                                                 cnt.  */
14029                                                              return 1398;
14030                                                            }
14031                                                        }
14032                                                      else
14033                                                        {
14034                                                          if (((word >> 19) & 0x1) == 0)
14035                                                            {
14036                                                              /* 33222222222211111111110000000000
14037                                                                 10987654321098765432109876543210
14038                                                                 000001x0xx0x0110101xxxxxxxxxxxxx
14039                                                                 abs.  */
14040                                                              return 1327;
14041                                                            }
14042                                                          else
14043                                                            {
14044                                                              /* 33222222222211111111110000000000
14045                                                                 10987654321098765432109876543210
14046                                                                 000001x0xx0x1110101xxxxxxxxxxxxx
14047                                                                 not.  */
14048                                                              return 1806;
14049                                                            }
14050                                                        }
14051                                                    }
14052                                                }
14053                                              else
14054                                                {
14055                                                  if (((word >> 17) & 0x1) == 0)
14056                                                    {
14057                                                      if (((word >> 18) & 0x1) == 0)
14058                                                        {
14059                                                          if (((word >> 19) & 0x1) == 0)
14060                                                            {
14061                                                              /* 33222222222211111111110000000000
14062                                                                 10987654321098765432109876543210
14063                                                                 000001x0xx0x0001101xxxxxxxxxxxxx
14064                                                                 uxtb.  */
14065                                                              return 2070;
14066                                                            }
14067                                                          else
14068                                                            {
14069                                                              /* 33222222222211111111110000000000
14070                                                                 10987654321098765432109876543210
14071                                                                 000001x0xx0x1001101xxxxxxxxxxxxx
14072                                                                 clz.  */
14073                                                              return 1370;
14074                                                            }
14075                                                        }
14076                                                      else
14077                                                        {
14078                                                          if (((word >> 19) & 0x1) == 0)
14079                                                            {
14080                                                              /* 33222222222211111111110000000000
14081                                                                 10987654321098765432109876543210
14082                                                                 000001x0xx0x0101101xxxxxxxxxxxxx
14083                                                                 uxtw.  */
14084                                                              return 2072;
14085                                                            }
14086                                                          else
14087                                                            {
14088                                                              /* 33222222222211111111110000000000
14089                                                                 10987654321098765432109876543210
14090                                                                 000001x0xx0x1101101xxxxxxxxxxxxx
14091                                                                 fneg.  */
14092                                                              return 1508;
14093                                                            }
14094                                                        }
14095                                                    }
14096                                                  else
14097                                                    {
14098                                                      if (((word >> 18) & 0x1) == 0)
14099                                                        {
14100                                                          if (((word >> 19) & 0x1) == 0)
14101                                                            {
14102                                                              /* 33222222222211111111110000000000
14103                                                                 10987654321098765432109876543210
14104                                                                 000001x0xx0x0011101xxxxxxxxxxxxx
14105                                                                 uxth.  */
14106                                                              return 2071;
14107                                                            }
14108                                                          else
14109                                                            {
14110                                                              /* 33222222222211111111110000000000
14111                                                                 10987654321098765432109876543210
14112                                                                 000001x0xx0x1011101xxxxxxxxxxxxx
14113                                                                 cnot.  */
14114                                                              return 1397;
14115                                                            }
14116                                                        }
14117                                                      else
14118                                                        {
14119                                                          /* 33222222222211111111110000000000
14120                                                             10987654321098765432109876543210
14121                                                             000001x0xx0xx111101xxxxxxxxxxxxx
14122                                                             neg.  */
14123                                                          return 1803;
14124                                                        }
14125                                                    }
14126                                                }
14127                                            }
14128                                          else
14129                                            {
14130                                              if (((word >> 12) & 0x1) == 0)
14131                                                {
14132                                                  if (((word >> 23) & 0x1) == 0)
14133                                                    {
14134                                                      if (((word >> 22) & 0x1) == 0)
14135                                                        {
14136                                                          /* 33222222222211111111110000000000
14137                                                             10987654321098765432109876543210
14138                                                             000001x0001xxxxx1010xxxxxxxxxxxx
14139                                                             adr.  */
14140                                                          return 1333;
14141                                                        }
14142                                                      else
14143                                                        {
14144                                                          /* 33222222222211111111110000000000
14145                                                             10987654321098765432109876543210
14146                                                             000001x0011xxxxx1010xxxxxxxxxxxx
14147                                                             adr.  */
14148                                                          return 1334;
14149                                                        }
14150                                                    }
14151                                                  else
14152                                                    {
14153                                                      /* 33222222222211111111110000000000
14154                                                         10987654321098765432109876543210
14155                                                         000001x01x1xxxxx1010xxxxxxxxxxxx
14156                                                         adr.  */
14157                                                      return 1335;
14158                                                    }
14159                                                }
14160                                              else
14161                                                {
14162                                                  if (((word >> 10) & 0x1) == 0)
14163                                                    {
14164                                                      if (((word >> 11) & 0x1) == 0)
14165                                                        {
14166                                                          /* 33222222222211111111110000000000
14167                                                             10987654321098765432109876543210
14168                                                             000001x0xx1xxxxx101100xxxxxxxxxx
14169                                                             ftssel.  */
14170                                                          return 1534;
14171                                                        }
14172                                                      else
14173                                                        {
14174                                                          /* 33222222222211111111110000000000
14175                                                             10987654321098765432109876543210
14176                                                             000001x0xx1xxxxx101110xxxxxxxxxx
14177                                                             fexpa.  */
14178                                                          return 1478;
14179                                                        }
14180                                                    }
14181                                                  else
14182                                                    {
14183                                                      /* 33222222222211111111110000000000
14184                                                         10987654321098765432109876543210
14185                                                         000001x0xx1xxxxx1011x1xxxxxxxxxx
14186                                                         movprfx.  */
14187                                                      return 1796;
14188                                                    }
14189                                                }
14190                                            }
14191                                        }
14192                                      else
14193                                        {
14194                                          if (((word >> 22) & 0x1) == 0)
14195                                            {
14196                                              if (((word >> 21) & 0x1) == 0)
14197                                                {
14198                                                  if (((word >> 23) & 0x1) == 0)
14199                                                    {
14200                                                      /* 33222222222211111111110000000000
14201                                                         10987654321098765432109876543210
14202                                                         100001x0000xxxxx101xxxxxxxxxxxxx
14203                                                         ldnt1b.  */
14204                                                      return 2145;
14205                                                    }
14206                                                  else
14207                                                    {
14208                                                      /* 33222222222211111111110000000000
14209                                                         10987654321098765432109876543210
14210                                                         100001x0100xxxxx101xxxxxxxxxxxxx
14211                                                         ldnt1h.  */
14212                                                      return 2148;
14213                                                    }
14214                                                }
14215                                              else
14216                                                {
14217                                                  if (((word >> 23) & 0x1) == 0)
14218                                                    {
14219                                                      /* 33222222222211111111110000000000
14220                                                         10987654321098765432109876543210
14221                                                         100001x0001xxxxx101xxxxxxxxxxxxx
14222                                                         ldff1sb.  */
14223                                                      return 1721;
14224                                                    }
14225                                                  else
14226                                                    {
14227                                                      /* 33222222222211111111110000000000
14228                                                         10987654321098765432109876543210
14229                                                         100001x0101xxxxx101xxxxxxxxxxxxx
14230                                                         ldff1sh.  */
14231                                                      return 1733;
14232                                                    }
14233                                                }
14234                                            }
14235                                          else
14236                                            {
14237                                              if (((word >> 23) & 0x1) == 0)
14238                                                {
14239                                                  /* 33222222222211111111110000000000
14240                                                     10987654321098765432109876543210
14241                                                     100001x001xxxxxx101xxxxxxxxxxxxx
14242                                                     ld1rb.  */
14243                                                  return 1589;
14244                                                }
14245                                              else
14246                                                {
14247                                                  /* 33222222222211111111110000000000
14248                                                     10987654321098765432109876543210
14249                                                     100001x011xxxxxx101xxxxxxxxxxxxx
14250                                                     ld1rh.  */
14251                                                  return 1593;
14252                                                }
14253                                            }
14254                                        }
14255                                    }
14256                                  else
14257                                    {
14258                                      if (((word >> 21) & 0x1) == 0)
14259                                        {
14260                                          if (((word >> 31) & 0x1) == 0)
14261                                            {
14262                                              if (((word >> 16) & 0x1) == 0)
14263                                                {
14264                                                  if (((word >> 17) & 0x1) == 0)
14265                                                    {
14266                                                      if (((word >> 18) & 0x1) == 0)
14267                                                        {
14268                                                          if (((word >> 19) & 0x1) == 0)
14269                                                            {
14270                                                              /* 33222222222211111111110000000000
14271                                                                 10987654321098765432109876543210
14272                                                                 010001x0xx0x0000101xxxxxxxxxxxxx
14273                                                                 urecpe.  */
14274                                                              return 2356;
14275                                                            }
14276                                                          else
14277                                                            {
14278                                                              /* 33222222222211111111110000000000
14279                                                                 10987654321098765432109876543210
14280                                                                 010001x0xx0x1000101xxxxxxxxxxxxx
14281                                                                 sqabs.  */
14282                                                              return 2218;
14283                                                            }
14284                                                        }
14285                                                      else
14286                                                        {
14287                                                          if (((word >> 20) & 0x1) == 0)
14288                                                            {
14289                                                              /* 33222222222211111111110000000000
14290                                                                 10987654321098765432109876543210
14291                                                                 010001x0xx00x100101xxxxxxxxxxxxx
14292                                                                 sadalp.  */
14293                                                              return 2182;
14294                                                            }
14295                                                          else
14296                                                            {
14297                                                              /* 33222222222211111111110000000000
14298                                                                 10987654321098765432109876543210
14299                                                                 010001x0xx01x100101xxxxxxxxxxxxx
14300                                                                 smaxp.  */
14301                                                              return 2196;
14302                                                            }
14303                                                        }
14304                                                    }
14305                                                  else
14306                                                    {
14307                                                      /* 33222222222211111111110000000000
14308                                                         10987654321098765432109876543210
14309                                                         010001x0xx0xxx10101xxxxxxxxxxxxx
14310                                                         sminp.  */
14311                                                      return 2197;
14312                                                    }
14313                                                }
14314                                              else
14315                                                {
14316                                                  if (((word >> 17) & 0x1) == 0)
14317                                                    {
14318                                                      if (((word >> 18) & 0x1) == 0)
14319                                                        {
14320                                                          if (((word >> 19) & 0x1) == 0)
14321                                                            {
14322                                                              if (((word >> 20) & 0x1) == 0)
14323                                                                {
14324                                                                  /* 33222222222211111111110000000000
14325                                                                     10987654321098765432109876543210
14326                                                                     010001x0xx000001101xxxxxxxxxxxxx
14327                                                                     ursqrte.  */
14328                                                                  return 2361;
14329                                                                }
14330                                                              else
14331                                                                {
14332                                                                  /* 33222222222211111111110000000000
14333                                                                     10987654321098765432109876543210
14334                                                                     010001x0xx010001101xxxxxxxxxxxxx
14335                                                                     addp.  */
14336                                                                  return 2107;
14337                                                                }
14338                                                            }
14339                                                          else
14340                                                            {
14341                                                              /* 33222222222211111111110000000000
14342                                                                 10987654321098765432109876543210
14343                                                                 010001x0xx0x1001101xxxxxxxxxxxxx
14344                                                                 sqneg.  */
14345                                                              return 2245;
14346                                                            }
14347                                                        }
14348                                                      else
14349                                                        {
14350                                                          if (((word >> 20) & 0x1) == 0)
14351                                                            {
14352                                                              /* 33222222222211111111110000000000
14353                                                                 10987654321098765432109876543210
14354                                                                 010001x0xx00x101101xxxxxxxxxxxxx
14355                                                                 uadalp.  */
14356                                                              return 2313;
14357                                                            }
14358                                                          else
14359                                                            {
14360                                                              /* 33222222222211111111110000000000
14361                                                                 10987654321098765432109876543210
14362                                                                 010001x0xx01x101101xxxxxxxxxxxxx
14363                                                                 umaxp.  */
14364                                                              return 2321;
14365                                                            }
14366                                                        }
14367                                                    }
14368                                                  else
14369                                                    {
14370                                                      /* 33222222222211111111110000000000
14371                                                         10987654321098765432109876543210
14372                                                         010001x0xx0xxx11101xxxxxxxxxxxxx
14373                                                         uminp.  */
14374                                                      return 2322;
14375                                                    }
14376                                                }
14377                                            }
14378                                          else
14379                                            {
14380                                              if (((word >> 22) & 0x1) == 0)
14381                                                {
14382                                                  /* 33222222222211111111110000000000
14383                                                     10987654321098765432109876543210
14384                                                     110001x0x00xxxxx101xxxxxxxxxxxxx
14385                                                     ld1q.  */
14386                                                  return 3309;
14387                                                }
14388                                              else
14389                                                {
14390                                                  if (((word >> 23) & 0x1) == 0)
14391                                                    {
14392                                                      /* 33222222222211111111110000000000
14393                                                         10987654321098765432109876543210
14394                                                         110001x0010xxxxx101xxxxxxxxxxxxx
14395                                                         ldff1sb.  */
14396                                                      return 1720;
14397                                                    }
14398                                                  else
14399                                                    {
14400                                                      /* 33222222222211111111110000000000
14401                                                         10987654321098765432109876543210
14402                                                         110001x0110xxxxx101xxxxxxxxxxxxx
14403                                                         ldff1sh.  */
14404                                                      return 1731;
14405                                                    }
14406                                                }
14407                                            }
14408                                        }
14409                                      else
14410                                        {
14411                                          if (((word >> 22) & 0x1) == 0)
14412                                            {
14413                                              if (((word >> 23) & 0x1) == 0)
14414                                                {
14415                                                  /* 33222222222211111111110000000000
14416                                                     10987654321098765432109876543210
14417                                                     x10001x0001xxxxx101xxxxxxxxxxxxx
14418                                                     ldff1sb.  */
14419                                                  return 1722;
14420                                                }
14421                                              else
14422                                                {
14423                                                  if (((word >> 31) & 0x1) == 0)
14424                                                    {
14425                                                      if (((word >> 10) & 0x1) == 0)
14426                                                        {
14427                                                          if (((word >> 12) & 0x1) == 0)
14428                                                            {
14429                                                              /* 33222222222211111111110000000000
14430                                                                 10987654321098765432109876543210
14431                                                                 010001x0101xxxxx1010x0xxxxxxxxxx
14432                                                                 smlslb.  */
14433                                                              return 2204;
14434                                                            }
14435                                                          else
14436                                                            {
14437                                                              /* 33222222222211111111110000000000
14438                                                                 10987654321098765432109876543210
14439                                                                 010001x0101xxxxx1011x0xxxxxxxxxx
14440                                                                 umlslb.  */
14441                                                              return 2329;
14442                                                            }
14443                                                        }
14444                                                      else
14445                                                        {
14446                                                          if (((word >> 12) & 0x1) == 0)
14447                                                            {
14448                                                              /* 33222222222211111111110000000000
14449                                                                 10987654321098765432109876543210
14450                                                                 010001x0101xxxxx1010x1xxxxxxxxxx
14451                                                                 smlslt.  */
14452                                                              return 2207;
14453                                                            }
14454                                                          else
14455                                                            {
14456                                                              /* 33222222222211111111110000000000
14457                                                                 10987654321098765432109876543210
14458                                                                 010001x0101xxxxx1011x1xxxxxxxxxx
14459                                                                 umlslt.  */
14460                                                              return 2332;
14461                                                            }
14462                                                        }
14463                                                    }
14464                                                  else
14465                                                    {
14466                                                      /* 33222222222211111111110000000000
14467                                                         10987654321098765432109876543210
14468                                                         110001x0101xxxxx101xxxxxxxxxxxxx
14469                                                         ldff1sh.  */
14470                                                      return 1734;
14471                                                    }
14472                                                }
14473                                            }
14474                                          else
14475                                            {
14476                                              if (((word >> 23) & 0x1) == 0)
14477                                                {
14478                                                  /* 33222222222211111111110000000000
14479                                                     10987654321098765432109876543210
14480                                                     x10001x0011xxxxx101xxxxxxxxxxxxx
14481                                                     prfh.  */
14482                                                  return 1836;
14483                                                }
14484                                              else
14485                                                {
14486                                                  if (((word >> 31) & 0x1) == 0)
14487                                                    {
14488                                                      if (((word >> 10) & 0x1) == 0)
14489                                                        {
14490                                                          if (((word >> 12) & 0x1) == 0)
14491                                                            {
14492                                                              /* 33222222222211111111110000000000
14493                                                                 10987654321098765432109876543210
14494                                                                 010001x0111xxxxx1010x0xxxxxxxxxx
14495                                                                 smlslb.  */
14496                                                              return 2205;
14497                                                            }
14498                                                          else
14499                                                            {
14500                                                              /* 33222222222211111111110000000000
14501                                                                 10987654321098765432109876543210
14502                                                                 010001x0111xxxxx1011x0xxxxxxxxxx
14503                                                                 umlslb.  */
14504                                                              return 2330;
14505                                                            }
14506                                                        }
14507                                                      else
14508                                                        {
14509                                                          if (((word >> 12) & 0x1) == 0)
14510                                                            {
14511                                                              /* 33222222222211111111110000000000
14512                                                                 10987654321098765432109876543210
14513                                                                 010001x0111xxxxx1010x1xxxxxxxxxx
14514                                                                 smlslt.  */
14515                                                              return 2208;
14516                                                            }
14517                                                          else
14518                                                            {
14519                                                              /* 33222222222211111111110000000000
14520                                                                 10987654321098765432109876543210
14521                                                                 010001x0111xxxxx1011x1xxxxxxxxxx
14522                                                                 umlslt.  */
14523                                                              return 2333;
14524                                                            }
14525                                                        }
14526                                                    }
14527                                                  else
14528                                                    {
14529                                                      /* 33222222222211111111110000000000
14530                                                         10987654321098765432109876543210
14531                                                         110001x0111xxxxx101xxxxxxxxxxxxx
14532                                                         ldff1sh.  */
14533                                                      return 1732;
14534                                                    }
14535                                                }
14536                                            }
14537                                        }
14538                                    }
14539                                }
14540                            }
14541                          else
14542                            {
14543                              if (((word >> 15) & 0x1) == 0)
14544                                {
14545                                  if (((word >> 21) & 0x1) == 0)
14546                                    {
14547                                      if (((word >> 30) & 0x1) == 0)
14548                                        {
14549                                          if (((word >> 31) & 0x1) == 0)
14550                                            {
14551                                              /* 33222222222211111111110000000000
14552                                                 10987654321098765432109876543210
14553                                                 000001x0xx0xxxxx011xxxxxxxxxxxxx
14554                                                 mls.  */
14555                                              return 1795;
14556                                            }
14557                                          else
14558                                            {
14559                                              if (((word >> 23) & 0x1) == 0)
14560                                                {
14561                                                  /* 33222222222211111111110000000000
14562                                                     10987654321098765432109876543210
14563                                                     100001x00x0xxxxx011xxxxxxxxxxxxx
14564                                                     ldff1b.  */
14565                                                  return 1678;
14566                                                }
14567                                              else
14568                                                {
14569                                                  /* 33222222222211111111110000000000
14570                                                     10987654321098765432109876543210
14571                                                     100001x01x0xxxxx011xxxxxxxxxxxxx
14572                                                     ldff1h.  */
14573                                                  return 1698;
14574                                                }
14575                                            }
14576                                        }
14577                                      else
14578                                        {
14579                                          if (((word >> 31) & 0x1) == 0)
14580                                            {
14581                                              if (((word >> 10) & 0x1) == 0)
14582                                                {
14583                                                  if (((word >> 11) & 0x1) == 0)
14584                                                    {
14585                                                      if (((word >> 12) & 0x1) == 0)
14586                                                        {
14587                                                          /* 33222222222211111111110000000000
14588                                                             10987654321098765432109876543210
14589                                                             010001x0xx0xxxxx011000xxxxxxxxxx
14590                                                             sqdmlalb.  */
14591                                                          return 2223;
14592                                                        }
14593                                                      else
14594                                                        {
14595                                                          /* 33222222222211111111110000000000
14596                                                             10987654321098765432109876543210
14597                                                             010001x0xx0xxxxx011100xxxxxxxxxx
14598                                                             sqrdmlah.  */
14599                                                          return 2252;
14600                                                        }
14601                                                    }
14602                                                  else
14603                                                    {
14604                                                      if (((word >> 12) & 0x1) == 0)
14605                                                        {
14606                                                          /* 33222222222211111111110000000000
14607                                                             10987654321098765432109876543210
14608                                                             010001x0xx0xxxxx011010xxxxxxxxxx
14609                                                             sqdmlslb.  */
14610                                                          return 2230;
14611                                                        }
14612                                                      else
14613                                                        {
14614                                                          /* 33222222222211111111110000000000
14615                                                             10987654321098765432109876543210
14616                                                             010001x0xx0xxxxx011110xxxxxxxxxx
14617                                                             usdot.  */
14618                                                          return 3029;
14619                                                        }
14620                                                    }
14621                                                }
14622                                              else
14623                                                {
14624                                                  if (((word >> 11) & 0x1) == 0)
14625                                                    {
14626                                                      if (((word >> 12) & 0x1) == 0)
14627                                                        {
14628                                                          /* 33222222222211111111110000000000
14629                                                             10987654321098765432109876543210
14630                                                             010001x0xx0xxxxx011001xxxxxxxxxx
14631                                                             sqdmlalt.  */
14632                                                          return 2227;
14633                                                        }
14634                                                      else
14635                                                        {
14636                                                          /* 33222222222211111111110000000000
14637                                                             10987654321098765432109876543210
14638                                                             010001x0xx0xxxxx011101xxxxxxxxxx
14639                                                             sqrdmlsh.  */
14640                                                          return 2256;
14641                                                        }
14642                                                    }
14643                                                  else
14644                                                    {
14645                                                      /* 33222222222211111111110000000000
14646                                                         10987654321098765432109876543210
14647                                                         010001x0xx0xxxxx011x11xxxxxxxxxx
14648                                                         sqdmlslt.  */
14649                                                      return 2234;
14650                                                    }
14651                                                }
14652                                            }
14653                                          else
14654                                            {
14655                                              if (((word >> 23) & 0x1) == 0)
14656                                                {
14657                                                  /* 33222222222211111111110000000000
14658                                                     10987654321098765432109876543210
14659                                                     110001x00x0xxxxx011xxxxxxxxxxxxx
14660                                                     ldff1b.  */
14661                                                  return 1687;
14662                                                }
14663                                              else
14664                                                {
14665                                                  /* 33222222222211111111110000000000
14666                                                     10987654321098765432109876543210
14667                                                     110001x01x0xxxxx011xxxxxxxxxxxxx
14668                                                     ldff1h.  */
14669                                                  return 1706;
14670                                                }
14671                                            }
14672                                        }
14673                                    }
14674                                  else
14675                                    {
14676                                      if (((word >> 30) & 0x1) == 0)
14677                                        {
14678                                          if (((word >> 31) & 0x1) == 0)
14679                                            {
14680                                              if (((word >> 10) & 0x1) == 0)
14681                                                {
14682                                                  if (((word >> 11) & 0x1) == 0)
14683                                                    {
14684                                                      if (((word >> 12) & 0x1) == 0)
14685                                                        {
14686                                                          /* 33222222222211111111110000000000
14687                                                             10987654321098765432109876543210
14688                                                             000001x0xx1xxxxx011000xxxxxxxxxx
14689                                                             mul.  */
14690                                                          return 2165;
14691                                                        }
14692                                                      else
14693                                                        {
14694                                                          /* 33222222222211111111110000000000
14695                                                             10987654321098765432109876543210
14696                                                             000001x0xx1xxxxx011100xxxxxxxxxx
14697                                                             sqdmulh.  */
14698                                                          return 2238;
14699                                                        }
14700                                                    }
14701                                                  else
14702                                                    {
14703                                                      /* 33222222222211111111110000000000
14704                                                         10987654321098765432109876543210
14705                                                         000001x0xx1xxxxx011x10xxxxxxxxxx
14706                                                         smulh.  */
14707                                                      return 2210;
14708                                                    }
14709                                                }
14710                                              else
14711                                                {
14712                                                  if (((word >> 11) & 0x1) == 0)
14713                                                    {
14714                                                      if (((word >> 12) & 0x1) == 0)
14715                                                        {
14716                                                          /* 33222222222211111111110000000000
14717                                                             10987654321098765432109876543210
14718                                                             000001x0xx1xxxxx011001xxxxxxxxxx
14719                                                             pmul.  */
14720                                                          return 2168;
14721                                                        }
14722                                                      else
14723                                                        {
14724                                                          /* 33222222222211111111110000000000
14725                                                             10987654321098765432109876543210
14726                                                             000001x0xx1xxxxx011101xxxxxxxxxx
14727                                                             sqrdmulh.  */
14728                                                          return 2260;
14729                                                        }
14730                                                    }
14731                                                  else
14732                                                    {
14733                                                      /* 33222222222211111111110000000000
14734                                                         10987654321098765432109876543210
14735                                                         000001x0xx1xxxxx011x11xxxxxxxxxx
14736                                                         umulh.  */
14737                                                      return 2335;
14738                                                    }
14739                                                }
14740                                            }
14741                                          else
14742                                            {
14743                                              if (((word >> 23) & 0x1) == 0)
14744                                                {
14745                                                  /* 33222222222211111111110000000000
14746                                                     10987654321098765432109876543210
14747                                                     100001x00x1xxxxx011xxxxxxxxxxxxx
14748                                                     prfd.  */
14749                                                  return 1826;
14750                                                }
14751                                              else
14752                                                {
14753                                                  /* 33222222222211111111110000000000
14754                                                     10987654321098765432109876543210
14755                                                     100001x01x1xxxxx011xxxxxxxxxxxxx
14756                                                     ldff1h.  */
14757                                                  return 1699;
14758                                                }
14759                                            }
14760                                        }
14761                                      else
14762                                        {
14763                                          if (((word >> 23) & 0x1) == 0)
14764                                            {
14765                                              /* 33222222222211111111110000000000
14766                                                 10987654321098765432109876543210
14767                                                 x10001x00x1xxxxx011xxxxxxxxxxxxx
14768                                                 prfd.  */
14769                                              return 1828;
14770                                            }
14771                                          else
14772                                            {
14773                                              if (((word >> 31) & 0x1) == 0)
14774                                                {
14775                                                  if (((word >> 12) & 0x1) == 0)
14776                                                    {
14777                                                      if (((word >> 22) & 0x1) == 0)
14778                                                        {
14779                                                          /* 33222222222211111111110000000000
14780                                                             10987654321098765432109876543210
14781                                                             010001x0101xxxxx0110xxxxxxxxxxxx
14782                                                             cmla.  */
14783                                                          return 2117;
14784                                                        }
14785                                                      else
14786                                                        {
14787                                                          /* 33222222222211111111110000000000
14788                                                             10987654321098765432109876543210
14789                                                             010001x0111xxxxx0110xxxxxxxxxxxx
14790                                                             cmla.  */
14791                                                          return 2118;
14792                                                        }
14793                                                    }
14794                                                  else
14795                                                    {
14796                                                      if (((word >> 22) & 0x1) == 0)
14797                                                        {
14798                                                          /* 33222222222211111111110000000000
14799                                                             10987654321098765432109876543210
14800                                                             010001x0101xxxxx0111xxxxxxxxxxxx
14801                                                             sqrdcmlah.  */
14802                                                          return 2246;
14803                                                        }
14804                                                      else
14805                                                        {
14806                                                          /* 33222222222211111111110000000000
14807                                                             10987654321098765432109876543210
14808                                                             010001x0111xxxxx0111xxxxxxxxxxxx
14809                                                             sqrdcmlah.  */
14810                                                          return 2247;
14811                                                        }
14812                                                    }
14813                                                }
14814                                              else
14815                                                {
14816                                                  /* 33222222222211111111110000000000
14817                                                     10987654321098765432109876543210
14818                                                     110001x01x1xxxxx011xxxxxxxxxxxxx
14819                                                     ldff1h.  */
14820                                                  return 1707;
14821                                                }
14822                                            }
14823                                        }
14824                                    }
14825                                }
14826                              else
14827                                {
14828                                  if (((word >> 30) & 0x1) == 0)
14829                                    {
14830                                      if (((word >> 31) & 0x1) == 0)
14831                                        {
14832                                          if (((word >> 21) & 0x1) == 0)
14833                                            {
14834                                              /* 33222222222211111111110000000000
14835                                                 10987654321098765432109876543210
14836                                                 000001x0xx0xxxxx111xxxxxxxxxxxxx
14837                                                 msb.  */
14838                                              return 1798;
14839                                            }
14840                                          else
14841                                            {
14842                                              if (((word >> 10) & 0x1) == 0)
14843                                                {
14844                                                  if (((word >> 11) & 0x1) == 0)
14845                                                    {
14846                                                      if (((word >> 12) & 0x1) == 0)
14847                                                        {
14848                                                          if (((word >> 20) & 0x1) == 0)
14849                                                            {
14850                                                              if (((word >> 22) & 0x1) == 0)
14851                                                                {
14852                                                                  if (((word >> 23) & 0x1) == 0)
14853                                                                    {
14854                                                                      /* 33222222222211111111110000000000
14855                                                                         10987654321098765432109876543210
14856                                                                         000001x00010xxxx111000xxxxxxxxxx
14857                                                                         cntb.  */
14858                                                                      return 1399;
14859                                                                    }
14860                                                                  else
14861                                                                    {
14862                                                                      /* 33222222222211111111110000000000
14863                                                                         10987654321098765432109876543210
14864                                                                         000001x01010xxxx111000xxxxxxxxxx
14865                                                                         cntw.  */
14866                                                                      return 1403;
14867                                                                    }
14868                                                                }
14869                                                              else
14870                                                                {
14871                                                                  if (((word >> 23) & 0x1) == 0)
14872                                                                    {
14873                                                                      /* 33222222222211111111110000000000
14874                                                                         10987654321098765432109876543210
14875                                                                         000001x00110xxxx111000xxxxxxxxxx
14876                                                                         cnth.  */
14877                                                                      return 1401;
14878                                                                    }
14879                                                                  else
14880                                                                    {
14881                                                                      /* 33222222222211111111110000000000
14882                                                                         10987654321098765432109876543210
14883                                                                         000001x01110xxxx111000xxxxxxxxxx
14884                                                                         cntd.  */
14885                                                                      return 1400;
14886                                                                    }
14887                                                                }
14888                                                            }
14889                                                          else
14890                                                            {
14891                                                              if (((word >> 22) & 0x1) == 0)
14892                                                                {
14893                                                                  if (((word >> 23) & 0x1) == 0)
14894                                                                    {
14895                                                                      /* 33222222222211111111110000000000
14896                                                                         10987654321098765432109876543210
14897                                                                         000001x00011xxxx111000xxxxxxxxxx
14898                                                                         incb.  */
14899                                                                      return 1535;
14900                                                                    }
14901                                                                  else
14902                                                                    {
14903                                                                      /* 33222222222211111111110000000000
14904                                                                         10987654321098765432109876543210
14905                                                                         000001x01011xxxx111000xxxxxxxxxx
14906                                                                         incw.  */
14907                                                                      return 1543;
14908                                                                    }
14909                                                                }
14910                                                              else
14911                                                                {
14912                                                                  if (((word >> 23) & 0x1) == 0)
14913                                                                    {
14914                                                                      /* 33222222222211111111110000000000
14915                                                                         10987654321098765432109876543210
14916                                                                         000001x00111xxxx111000xxxxxxxxxx
14917                                                                         inch.  */
14918                                                                      return 1539;
14919                                                                    }
14920                                                                  else
14921                                                                    {
14922                                                                      /* 33222222222211111111110000000000
14923                                                                         10987654321098765432109876543210
14924                                                                         000001x01111xxxx111000xxxxxxxxxx
14925                                                                         incd.  */
14926                                                                      return 1537;
14927                                                                    }
14928                                                                }
14929                                                            }
14930                                                        }
14931                                                      else
14932                                                        {
14933                                                          if (((word >> 20) & 0x1) == 0)
14934                                                            {
14935                                                              if (((word >> 22) & 0x1) == 0)
14936                                                                {
14937                                                                  if (((word >> 23) & 0x1) == 0)
14938                                                                    {
14939                                                                      /* 33222222222211111111110000000000
14940                                                                         10987654321098765432109876543210
14941                                                                         000001x00010xxxx111100xxxxxxxxxx
14942                                                                         sqincb.  */
14943                                                                      return 1904;
14944                                                                    }
14945                                                                  else
14946                                                                    {
14947                                                                      /* 33222222222211111111110000000000
14948                                                                         10987654321098765432109876543210
14949                                                                         000001x01010xxxx111100xxxxxxxxxx
14950                                                                         sqincw.  */
14951                                                                      return 1916;
14952                                                                    }
14953                                                                }
14954                                                              else
14955                                                                {
14956                                                                  if (((word >> 23) & 0x1) == 0)
14957                                                                    {
14958                                                                      /* 33222222222211111111110000000000
14959                                                                         10987654321098765432109876543210
14960                                                                         000001x00110xxxx111100xxxxxxxxxx
14961                                                                         sqinch.  */
14962                                                                      return 1910;
14963                                                                    }
14964                                                                  else
14965                                                                    {
14966                                                                      /* 33222222222211111111110000000000
14967                                                                         10987654321098765432109876543210
14968                                                                         000001x01110xxxx111100xxxxxxxxxx
14969                                                                         sqincd.  */
14970                                                                      return 1907;
14971                                                                    }
14972                                                                }
14973                                                            }
14974                                                          else
14975                                                            {
14976                                                              if (((word >> 22) & 0x1) == 0)
14977                                                                {
14978                                                                  if (((word >> 23) & 0x1) == 0)
14979                                                                    {
14980                                                                      /* 33222222222211111111110000000000
14981                                                                         10987654321098765432109876543210
14982                                                                         000001x00011xxxx111100xxxxxxxxxx
14983                                                                         sqincb.  */
14984                                                                      return 1903;
14985                                                                    }
14986                                                                  else
14987                                                                    {
14988                                                                      /* 33222222222211111111110000000000
14989                                                                         10987654321098765432109876543210
14990                                                                         000001x01011xxxx111100xxxxxxxxxx
14991                                                                         sqincw.  */
14992                                                                      return 1915;
14993                                                                    }
14994                                                                }
14995                                                              else
14996                                                                {
14997                                                                  if (((word >> 23) & 0x1) == 0)
14998                                                                    {
14999                                                                      /* 33222222222211111111110000000000
15000                                                                         10987654321098765432109876543210
15001                                                                         000001x00111xxxx111100xxxxxxxxxx
15002                                                                         sqinch.  */
15003                                                                      return 1909;
15004                                                                    }
15005                                                                  else
15006                                                                    {
15007                                                                      /* 33222222222211111111110000000000
15008                                                                         10987654321098765432109876543210
15009                                                                         000001x01111xxxx111100xxxxxxxxxx
15010                                                                         sqincd.  */
15011                                                                      return 1906;
15012                                                                    }
15013                                                                }
15014                                                            }
15015                                                        }
15016                                                    }
15017                                                  else
15018                                                    {
15019                                                      if (((word >> 20) & 0x1) == 0)
15020                                                        {
15021                                                          if (((word >> 22) & 0x1) == 0)
15022                                                            {
15023                                                              if (((word >> 23) & 0x1) == 0)
15024                                                                {
15025                                                                  /* 33222222222211111111110000000000
15026                                                                     10987654321098765432109876543210
15027                                                                     000001x00010xxxx111x10xxxxxxxxxx
15028                                                                     sqdecb.  */
15029                                                                  return 1890;
15030                                                                }
15031                                                              else
15032                                                                {
15033                                                                  /* 33222222222211111111110000000000
15034                                                                     10987654321098765432109876543210
15035                                                                     000001x01010xxxx111x10xxxxxxxxxx
15036                                                                     sqdecw.  */
15037                                                                  return 1902;
15038                                                                }
15039                                                            }
15040                                                          else
15041                                                            {
15042                                                              if (((word >> 23) & 0x1) == 0)
15043                                                                {
15044                                                                  /* 33222222222211111111110000000000
15045                                                                     10987654321098765432109876543210
15046                                                                     000001x00110xxxx111x10xxxxxxxxxx
15047                                                                     sqdech.  */
15048                                                                  return 1896;
15049                                                                }
15050                                                              else
15051                                                                {
15052                                                                  /* 33222222222211111111110000000000
15053                                                                     10987654321098765432109876543210
15054                                                                     000001x01110xxxx111x10xxxxxxxxxx
15055                                                                     sqdecd.  */
15056                                                                  return 1893;
15057                                                                }
15058                                                            }
15059                                                        }
15060                                                      else
15061                                                        {
15062                                                          if (((word >> 22) & 0x1) == 0)
15063                                                            {
15064                                                              if (((word >> 23) & 0x1) == 0)
15065                                                                {
15066                                                                  /* 33222222222211111111110000000000
15067                                                                     10987654321098765432109876543210
15068                                                                     000001x00011xxxx111x10xxxxxxxxxx
15069                                                                     sqdecb.  */
15070                                                                  return 1889;
15071                                                                }
15072                                                              else
15073                                                                {
15074                                                                  /* 33222222222211111111110000000000
15075                                                                     10987654321098765432109876543210
15076                                                                     000001x01011xxxx111x10xxxxxxxxxx
15077                                                                     sqdecw.  */
15078                                                                  return 1901;
15079                                                                }
15080                                                            }
15081                                                          else
15082                                                            {
15083                                                              if (((word >> 23) & 0x1) == 0)
15084                                                                {
15085                                                                  /* 33222222222211111111110000000000
15086                                                                     10987654321098765432109876543210
15087                                                                     000001x00111xxxx111x10xxxxxxxxxx
15088                                                                     sqdech.  */
15089                                                                  return 1895;
15090                                                                }
15091                                                              else
15092                                                                {
15093                                                                  /* 33222222222211111111110000000000
15094                                                                     10987654321098765432109876543210
15095                                                                     000001x01111xxxx111x10xxxxxxxxxx
15096                                                                     sqdecd.  */
15097                                                                  return 1892;
15098                                                                }
15099                                                            }
15100                                                        }
15101                                                    }
15102                                                }
15103                                              else
15104                                                {
15105                                                  if (((word >> 11) & 0x1) == 0)
15106                                                    {
15107                                                      if (((word >> 12) & 0x1) == 0)
15108                                                        {
15109                                                          if (((word >> 22) & 0x1) == 0)
15110                                                            {
15111                                                              if (((word >> 23) & 0x1) == 0)
15112                                                                {
15113                                                                  /* 33222222222211111111110000000000
15114                                                                     10987654321098765432109876543210
15115                                                                     000001x0001xxxxx111001xxxxxxxxxx
15116                                                                     decb.  */
15117                                                                  return 1410;
15118                                                                }
15119                                                              else
15120                                                                {
15121                                                                  /* 33222222222211111111110000000000
15122                                                                     10987654321098765432109876543210
15123                                                                     000001x0101xxxxx111001xxxxxxxxxx
15124                                                                     decw.  */
15125                                                                  return 1418;
15126                                                                }
15127                                                            }
15128                                                          else
15129                                                            {
15130                                                              if (((word >> 23) & 0x1) == 0)
15131                                                                {
15132                                                                  /* 33222222222211111111110000000000
15133                                                                     10987654321098765432109876543210
15134                                                                     000001x0011xxxxx111001xxxxxxxxxx
15135                                                                     dech.  */
15136                                                                  return 1414;
15137                                                                }
15138                                                              else
15139                                                                {
15140                                                                  /* 33222222222211111111110000000000
15141                                                                     10987654321098765432109876543210
15142                                                                     000001x0111xxxxx111001xxxxxxxxxx
15143                                                                     decd.  */
15144                                                                  return 1412;
15145                                                                }
15146                                                            }
15147                                                        }
15148                                                      else
15149                                                        {
15150                                                          if (((word >> 20) & 0x1) == 0)
15151                                                            {
15152                                                              if (((word >> 22) & 0x1) == 0)
15153                                                                {
15154                                                                  if (((word >> 23) & 0x1) == 0)
15155                                                                    {
15156                                                                      /* 33222222222211111111110000000000
15157                                                                         10987654321098765432109876543210
15158                                                                         000001x00010xxxx111101xxxxxxxxxx
15159                                                                         uqincb.  */
15160                                                                      return 2052;
15161                                                                    }
15162                                                                  else
15163                                                                    {
15164                                                                      /* 33222222222211111111110000000000
15165                                                                         10987654321098765432109876543210
15166                                                                         000001x01010xxxx111101xxxxxxxxxx
15167                                                                         uqincw.  */
15168                                                                      return 2064;
15169                                                                    }
15170                                                                }
15171                                                              else
15172                                                                {
15173                                                                  if (((word >> 23) & 0x1) == 0)
15174                                                                    {
15175                                                                      /* 33222222222211111111110000000000
15176                                                                         10987654321098765432109876543210
15177                                                                         000001x00110xxxx111101xxxxxxxxxx
15178                                                                         uqinch.  */
15179                                                                      return 2058;
15180                                                                    }
15181                                                                  else
15182                                                                    {
15183                                                                      /* 33222222222211111111110000000000
15184                                                                         10987654321098765432109876543210
15185                                                                         000001x01110xxxx111101xxxxxxxxxx
15186                                                                         uqincd.  */
15187                                                                      return 2055;
15188                                                                    }
15189                                                                }
15190                                                            }
15191                                                          else
15192                                                            {
15193                                                              if (((word >> 22) & 0x1) == 0)
15194                                                                {
15195                                                                  if (((word >> 23) & 0x1) == 0)
15196                                                                    {
15197                                                                      /* 33222222222211111111110000000000
15198                                                                         10987654321098765432109876543210
15199                                                                         000001x00011xxxx111101xxxxxxxxxx
15200                                                                         uqincb.  */
15201                                                                      return 2053;
15202                                                                    }
15203                                                                  else
15204                                                                    {
15205                                                                      /* 33222222222211111111110000000000
15206                                                                         10987654321098765432109876543210
15207                                                                         000001x01011xxxx111101xxxxxxxxxx
15208                                                                         uqincw.  */
15209                                                                      return 2065;
15210                                                                    }
15211                                                                }
15212                                                              else
15213                                                                {
15214                                                                  if (((word >> 23) & 0x1) == 0)
15215                                                                    {
15216                                                                      /* 33222222222211111111110000000000
15217                                                                         10987654321098765432109876543210
15218                                                                         000001x00111xxxx111101xxxxxxxxxx
15219                                                                         uqinch.  */
15220                                                                      return 2059;
15221                                                                    }
15222                                                                  else
15223                                                                    {
15224                                                                      /* 33222222222211111111110000000000
15225                                                                         10987654321098765432109876543210
15226                                                                         000001x01111xxxx111101xxxxxxxxxx
15227                                                                         uqincd.  */
15228                                                                      return 2056;
15229                                                                    }
15230                                                                }
15231                                                            }
15232                                                        }
15233                                                    }
15234                                                  else
15235                                                    {
15236                                                      if (((word >> 20) & 0x1) == 0)
15237                                                        {
15238                                                          if (((word >> 22) & 0x1) == 0)
15239                                                            {
15240                                                              if (((word >> 23) & 0x1) == 0)
15241                                                                {
15242                                                                  /* 33222222222211111111110000000000
15243                                                                     10987654321098765432109876543210
15244                                                                     000001x00010xxxx111x11xxxxxxxxxx
15245                                                                     uqdecb.  */
15246                                                                  return 2038;
15247                                                                }
15248                                                              else
15249                                                                {
15250                                                                  /* 33222222222211111111110000000000
15251                                                                     10987654321098765432109876543210
15252                                                                     000001x01010xxxx111x11xxxxxxxxxx
15253                                                                     uqdecw.  */
15254                                                                  return 2050;
15255                                                                }
15256                                                            }
15257                                                          else
15258                                                            {
15259                                                              if (((word >> 23) & 0x1) == 0)
15260                                                                {
15261                                                                  /* 33222222222211111111110000000000
15262                                                                     10987654321098765432109876543210
15263                                                                     000001x00110xxxx111x11xxxxxxxxxx
15264                                                                     uqdech.  */
15265                                                                  return 2044;
15266                                                                }
15267                                                              else
15268                                                                {
15269                                                                  /* 33222222222211111111110000000000
15270                                                                     10987654321098765432109876543210
15271                                                                     000001x01110xxxx111x11xxxxxxxxxx
15272                                                                     uqdecd.  */
15273                                                                  return 2041;
15274                                                                }
15275                                                            }
15276                                                        }
15277                                                      else
15278                                                        {
15279                                                          if (((word >> 22) & 0x1) == 0)
15280                                                            {
15281                                                              if (((word >> 23) & 0x1) == 0)
15282                                                                {
15283                                                                  /* 33222222222211111111110000000000
15284                                                                     10987654321098765432109876543210
15285                                                                     000001x00011xxxx111x11xxxxxxxxxx
15286                                                                     uqdecb.  */
15287                                                                  return 2039;
15288                                                                }
15289                                                              else
15290                                                                {
15291                                                                  /* 33222222222211111111110000000000
15292                                                                     10987654321098765432109876543210
15293                                                                     000001x01011xxxx111x11xxxxxxxxxx
15294                                                                     uqdecw.  */
15295                                                                  return 2051;
15296                                                                }
15297                                                            }
15298                                                          else
15299                                                            {
15300                                                              if (((word >> 23) & 0x1) == 0)
15301                                                                {
15302                                                                  /* 33222222222211111111110000000000
15303                                                                     10987654321098765432109876543210
15304                                                                     000001x00111xxxx111x11xxxxxxxxxx
15305                                                                     uqdech.  */
15306                                                                  return 2045;
15307                                                                }
15308                                                              else
15309                                                                {
15310                                                                  /* 33222222222211111111110000000000
15311                                                                     10987654321098765432109876543210
15312                                                                     000001x01111xxxx111x11xxxxxxxxxx
15313                                                                     uqdecd.  */
15314                                                                  return 2042;
15315                                                                }
15316                                                            }
15317                                                        }
15318                                                    }
15319                                                }
15320                                            }
15321                                        }
15322                                      else
15323                                        {
15324                                          if (((word >> 22) & 0x1) == 0)
15325                                            {
15326                                              if (((word >> 21) & 0x1) == 0)
15327                                                {
15328                                                  if (((word >> 23) & 0x1) == 0)
15329                                                    {
15330                                                      /* 33222222222211111111110000000000
15331                                                         10987654321098765432109876543210
15332                                                         100001x0000xxxxx111xxxxxxxxxxxxx
15333                                                         prfb.  */
15334                                                      return 1823;
15335                                                    }
15336                                                  else
15337                                                    {
15338                                                      /* 33222222222211111111110000000000
15339                                                         10987654321098765432109876543210
15340                                                         100001x0100xxxxx111xxxxxxxxxxxxx
15341                                                         prfh.  */
15342                                                      return 1837;
15343                                                    }
15344                                                }
15345                                              else
15346                                                {
15347                                                  if (((word >> 23) & 0x1) == 0)
15348                                                    {
15349                                                      /* 33222222222211111111110000000000
15350                                                         10987654321098765432109876543210
15351                                                         100001x0001xxxxx111xxxxxxxxxxxxx
15352                                                         ldff1b.  */
15353                                                      return 1689;
15354                                                    }
15355                                                  else
15356                                                    {
15357                                                      /* 33222222222211111111110000000000
15358                                                         10987654321098765432109876543210
15359                                                         100001x0101xxxxx111xxxxxxxxxxxxx
15360                                                         ldff1h.  */
15361                                                      return 1710;
15362                                                    }
15363                                                }
15364                                            }
15365                                          else
15366                                            {
15367                                              if (((word >> 23) & 0x1) == 0)
15368                                                {
15369                                                  /* 33222222222211111111110000000000
15370                                                     10987654321098765432109876543210
15371                                                     100001x001xxxxxx111xxxxxxxxxxxxx
15372                                                     ld1rb.  */
15373                                                  return 1591;
15374                                                }
15375                                              else
15376                                                {
15377                                                  /* 33222222222211111111110000000000
15378                                                     10987654321098765432109876543210
15379                                                     100001x011xxxxxx111xxxxxxxxxxxxx
15380                                                     ld1rh.  */
15381                                                  return 1595;
15382                                                }
15383                                            }
15384                                        }
15385                                    }
15386                                  else
15387                                    {
15388                                      if (((word >> 21) & 0x1) == 0)
15389                                        {
15390                                          if (((word >> 22) & 0x1) == 0)
15391                                            {
15392                                              if (((word >> 23) & 0x1) == 0)
15393                                                {
15394                                                  /* 33222222222211111111110000000000
15395                                                     10987654321098765432109876543210
15396                                                     x10001x0000xxxxx111xxxxxxxxxxxxx
15397                                                     prfb.  */
15398                                                  return 1825;
15399                                                }
15400                                              else
15401                                                {
15402                                                  /* 33222222222211111111110000000000
15403                                                     10987654321098765432109876543210
15404                                                     x10001x0100xxxxx111xxxxxxxxxxxxx
15405                                                     prfh.  */
15406                                                  return 1839;
15407                                                }
15408                                            }
15409                                          else
15410                                            {
15411                                              if (((word >> 23) & 0x1) == 0)
15412                                                {
15413                                                  /* 33222222222211111111110000000000
15414                                                     10987654321098765432109876543210
15415                                                     x10001x0010xxxxx111xxxxxxxxxxxxx
15416                                                     ldff1b.  */
15417                                                  return 1688;
15418                                                }
15419                                              else
15420                                                {
15421                                                  /* 33222222222211111111110000000000
15422                                                     10987654321098765432109876543210
15423                                                     x10001x0110xxxxx111xxxxxxxxxxxxx
15424                                                     ldff1h.  */
15425                                                  return 1708;
15426                                                }
15427                                            }
15428                                        }
15429                                      else
15430                                        {
15431                                          if (((word >> 23) & 0x1) == 0)
15432                                            {
15433                                              if (((word >> 31) & 0x1) == 0)
15434                                                {
15435                                                  if (((word >> 10) & 0x1) == 0)
15436                                                    {
15437                                                      if (((word >> 11) & 0x1) == 0)
15438                                                        {
15439                                                          /* 33222222222211111111110000000000
15440                                                             10987654321098765432109876543210
15441                                                             010001x00x1xxxxx111x00xxxxxxxxxx
15442                                                             sqdmulh.  */
15443                                                          return 2235;
15444                                                        }
15445                                                      else
15446                                                        {
15447                                                          /* 33222222222211111111110000000000
15448                                                             10987654321098765432109876543210
15449                                                             010001x00x1xxxxx111x10xxxxxxxxxx
15450                                                             mul.  */
15451                                                          return 2162;
15452                                                        }
15453                                                    }
15454                                                  else
15455                                                    {
15456                                                      /* 33222222222211111111110000000000
15457                                                         10987654321098765432109876543210
15458                                                         010001x00x1xxxxx111xx1xxxxxxxxxx
15459                                                         sqrdmulh.  */
15460                                                      return 2257;
15461                                                    }
15462                                                }
15463                                              else
15464                                                {
15465                                                  if (((word >> 22) & 0x1) == 0)
15466                                                    {
15467                                                      /* 33222222222211111111110000000000
15468                                                         10987654321098765432109876543210
15469                                                         110001x0001xxxxx111xxxxxxxxxxxxx
15470                                                         ldff1b.  */
15471                                                      return 1690;
15472                                                    }
15473                                                  else
15474                                                    {
15475                                                      /* 33222222222211111111110000000000
15476                                                         10987654321098765432109876543210
15477                                                         110001x0011xxxxx111xxxxxxxxxxxxx
15478                                                         prfd.  */
15479                                                      return 1829;
15480                                                    }
15481                                                }
15482                                            }
15483                                          else
15484                                            {
15485                                              if (((word >> 22) & 0x1) == 0)
15486                                                {
15487                                                  if (((word >> 31) & 0x1) == 0)
15488                                                    {
15489                                                      if (((word >> 10) & 0x1) == 0)
15490                                                        {
15491                                                          if (((word >> 12) & 0x1) == 0)
15492                                                            {
15493                                                              /* 33222222222211111111110000000000
15494                                                                 10987654321098765432109876543210
15495                                                                 010001x0101xxxxx1110x0xxxxxxxxxx
15496                                                                 sqdmullb.  */
15497                                                              return 2239;
15498                                                            }
15499                                                          else
15500                                                            {
15501                                                              if (((word >> 11) & 0x1) == 0)
15502                                                                {
15503                                                                  /* 33222222222211111111110000000000
15504                                                                     10987654321098765432109876543210
15505                                                                     010001x0101xxxxx111100xxxxxxxxxx
15506                                                                     sqdmulh.  */
15507                                                                  return 2236;
15508                                                                }
15509                                                              else
15510                                                                {
15511                                                                  /* 33222222222211111111110000000000
15512                                                                     10987654321098765432109876543210
15513                                                                     010001x0101xxxxx111110xxxxxxxxxx
15514                                                                     mul.  */
15515                                                                  return 2163;
15516                                                                }
15517                                                            }
15518                                                        }
15519                                                      else
15520                                                        {
15521                                                          if (((word >> 12) & 0x1) == 0)
15522                                                            {
15523                                                              /* 33222222222211111111110000000000
15524                                                                 10987654321098765432109876543210
15525                                                                 010001x0101xxxxx1110x1xxxxxxxxxx
15526                                                                 sqdmullt.  */
15527                                                              return 2242;
15528                                                            }
15529                                                          else
15530                                                            {
15531                                                              /* 33222222222211111111110000000000
15532                                                                 10987654321098765432109876543210
15533                                                                 010001x0101xxxxx1111x1xxxxxxxxxx
15534                                                                 sqrdmulh.  */
15535                                                              return 2258;
15536                                                            }
15537                                                        }
15538                                                    }
15539                                                  else
15540                                                    {
15541                                                      /* 33222222222211111111110000000000
15542                                                         10987654321098765432109876543210
15543                                                         110001x0101xxxxx111xxxxxxxxxxxxx
15544                                                         ldff1h.  */
15545                                                      return 1711;
15546                                                    }
15547                                                }
15548                                              else
15549                                                {
15550                                                  if (((word >> 31) & 0x1) == 0)
15551                                                    {
15552                                                      if (((word >> 10) & 0x1) == 0)
15553                                                        {
15554                                                          if (((word >> 12) & 0x1) == 0)
15555                                                            {
15556                                                              /* 33222222222211111111110000000000
15557                                                                 10987654321098765432109876543210
15558                                                                 010001x0111xxxxx1110x0xxxxxxxxxx
15559                                                                 sqdmullb.  */
15560                                                              return 2240;
15561                                                            }
15562                                                          else
15563                                                            {
15564                                                              if (((word >> 11) & 0x1) == 0)
15565                                                                {
15566                                                                  /* 33222222222211111111110000000000
15567                                                                     10987654321098765432109876543210
15568                                                                     010001x0111xxxxx111100xxxxxxxxxx
15569                                                                     sqdmulh.  */
15570                                                                  return 2237;
15571                                                                }
15572                                                              else
15573                                                                {
15574                                                                  /* 33222222222211111111110000000000
15575                                                                     10987654321098765432109876543210
15576                                                                     010001x0111xxxxx111110xxxxxxxxxx
15577                                                                     mul.  */
15578                                                                  return 2164;
15579                                                                }
15580                                                            }
15581                                                        }
15582                                                      else
15583                                                        {
15584                                                          if (((word >> 12) & 0x1) == 0)
15585                                                            {
15586                                                              /* 33222222222211111111110000000000
15587                                                                 10987654321098765432109876543210
15588                                                                 010001x0111xxxxx1110x1xxxxxxxxxx
15589                                                                 sqdmullt.  */
15590                                                              return 2243;
15591                                                            }
15592                                                          else
15593                                                            {
15594                                                              /* 33222222222211111111110000000000
15595                                                                 10987654321098765432109876543210
15596                                                                 010001x0111xxxxx1111x1xxxxxxxxxx
15597                                                                 sqrdmulh.  */
15598                                                              return 2259;
15599                                                            }
15600                                                        }
15601                                                    }
15602                                                  else
15603                                                    {
15604                                                      /* 33222222222211111111110000000000
15605                                                         10987654321098765432109876543210
15606                                                         110001x0111xxxxx111xxxxxxxxxxxxx
15607                                                         ldff1h.  */
15608                                                      return 1709;
15609                                                    }
15610                                                }
15611                                            }
15612                                        }
15613                                    }
15614                                }
15615                            }
15616                        }
15617                    }
15618                  else
15619                    {
15620                      if (((word >> 21) & 0x1) == 0)
15621                        {
15622                          if (((word >> 15) & 0x1) == 0)
15623                            {
15624                              if (((word >> 30) & 0x1) == 0)
15625                                {
15626                                  if (((word >> 13) & 0x1) == 0)
15627                                    {
15628                                      if (((word >> 14) & 0x1) == 0)
15629                                        {
15630                                          if (((word >> 31) & 0x1) == 0)
15631                                            {
15632                                              if (((word >> 4) & 0x1) == 0)
15633                                                {
15634                                                  /* 33222222222211111111110000000000
15635                                                     10987654321098765432109876543210
15636                                                     001001x0xx0xxxxx000xxxxxxxx0xxxx
15637                                                     cmphs.  */
15638                                                  return 1383;
15639                                                }
15640                                              else
15641                                                {
15642                                                  /* 33222222222211111111110000000000
15643                                                     10987654321098765432109876543210
15644                                                     001001x0xx0xxxxx000xxxxxxxx1xxxx
15645                                                     cmphi.  */
15646                                                  return 1380;
15647                                                }
15648                                            }
15649                                          else
15650                                            {
15651                                              if (((word >> 23) & 0x1) == 0)
15652                                                {
15653                                                  /* 33222222222211111111110000000000
15654                                                     10987654321098765432109876543210
15655                                                     101001x00x0xxxxx000xxxxxxxxxxxxx
15656                                                     ld1rqb.  */
15657                                                  return 1597;
15658                                                }
15659                                              else
15660                                                {
15661                                                  /* 33222222222211111111110000000000
15662                                                     10987654321098765432109876543210
15663                                                     101001x01x0xxxxx000xxxxxxxxxxxxx
15664                                                     ld1rqh.  */
15665                                                  return 1601;
15666                                                }
15667                                            }
15668                                        }
15669                                      else
15670                                        {
15671                                          if (((word >> 31) & 0x1) == 0)
15672                                            {
15673                                              if (((word >> 4) & 0x1) == 0)
15674                                                {
15675                                                  /* 33222222222211111111110000000000
15676                                                     10987654321098765432109876543210
15677                                                     001001x0xx0xxxxx010xxxxxxxx0xxxx
15678                                                     cmpge.  */
15679                                                  return 1374;
15680                                                }
15681                                              else
15682                                                {
15683                                                  /* 33222222222211111111110000000000
15684                                                     10987654321098765432109876543210
15685                                                     001001x0xx0xxxxx010xxxxxxxx1xxxx
15686                                                     cmpgt.  */
15687                                                  return 1377;
15688                                                }
15689                                            }
15690                                          else
15691                                            {
15692                                              if (((word >> 22) & 0x1) == 0)
15693                                                {
15694                                                  if (((word >> 23) & 0x1) == 0)
15695                                                    {
15696                                                      /* 33222222222211111111110000000000
15697                                                         10987654321098765432109876543210
15698                                                         101001x0000xxxxx010xxxxxxxxxxxxx
15699                                                         ld1b.  */
15700                                                      return 1555;
15701                                                    }
15702                                                  else
15703                                                    {
15704                                                      /* 33222222222211111111110000000000
15705                                                         10987654321098765432109876543210
15706                                                         101001x0100xxxxx010xxxxxxxxxxxxx
15707                                                         ld1sw.  */
15708                                                      return 1635;
15709                                                    }
15710                                                }
15711                                              else
15712                                                {
15713                                                  if (((word >> 23) & 0x1) == 0)
15714                                                    {
15715                                                      /* 33222222222211111111110000000000
15716                                                         10987654321098765432109876543210
15717                                                         101001x0010xxxxx010xxxxxxxxxxxxx
15718                                                         ld1b.  */
15719                                                      return 1557;
15720                                                    }
15721                                                  else
15722                                                    {
15723                                                      /* 33222222222211111111110000000000
15724                                                         10987654321098765432109876543210
15725                                                         101001x0110xxxxx010xxxxxxxxxxxxx
15726                                                         ld1h.  */
15727                                                      return 1577;
15728                                                    }
15729                                                }
15730                                            }
15731                                        }
15732                                    }
15733                                  else
15734                                    {
15735                                      if (((word >> 14) & 0x1) == 0)
15736                                        {
15737                                          if (((word >> 31) & 0x1) == 0)
15738                                            {
15739                                              if (((word >> 4) & 0x1) == 0)
15740                                                {
15741                                                  /* 33222222222211111111110000000000
15742                                                     10987654321098765432109876543210
15743                                                     001001x0xx0xxxxx001xxxxxxxx0xxxx
15744                                                     cmpeq.  */
15745                                                  return 1371;
15746                                                }
15747                                              else
15748                                                {
15749                                                  /* 33222222222211111111110000000000
15750                                                     10987654321098765432109876543210
15751                                                     001001x0xx0xxxxx001xxxxxxxx1xxxx
15752                                                     cmpne.  */
15753                                                  return 1394;
15754                                                }
15755                                            }
15756                                          else
15757                                            {
15758                                              if (((word >> 23) & 0x1) == 0)
15759                                                {
15760                                                  /* 33222222222211111111110000000000
15761                                                     10987654321098765432109876543210
15762                                                     101001x00x0xxxxx001xxxxxxxxxxxxx
15763                                                     ld1rqb.  */
15764                                                  return 1596;
15765                                                }
15766                                              else
15767                                                {
15768                                                  /* 33222222222211111111110000000000
15769                                                     10987654321098765432109876543210
15770                                                     101001x01x0xxxxx001xxxxxxxxxxxxx
15771                                                     ld1rqh.  */
15772                                                  return 1600;
15773                                                }
15774                                            }
15775                                        }
15776                                      else
15777                                        {
15778                                          if (((word >> 31) & 0x1) == 0)
15779                                            {
15780                                              if (((word >> 4) & 0x1) == 0)
15781                                                {
15782                                                  /* 33222222222211111111110000000000
15783                                                     10987654321098765432109876543210
15784                                                     001001x0xx0xxxxx011xxxxxxxx0xxxx
15785                                                     cmplt.  */
15786                                                  return 1392;
15787                                                }
15788                                              else
15789                                                {
15790                                                  /* 33222222222211111111110000000000
15791                                                     10987654321098765432109876543210
15792                                                     001001x0xx0xxxxx011xxxxxxxx1xxxx
15793                                                     cmple.  */
15794                                                  return 1386;
15795                                                }
15796                                            }
15797                                          else
15798                                            {
15799                                              if (((word >> 22) & 0x1) == 0)
15800                                                {
15801                                                  if (((word >> 23) & 0x1) == 0)
15802                                                    {
15803                                                      /* 33222222222211111111110000000000
15804                                                         10987654321098765432109876543210
15805                                                         101001x0000xxxxx011xxxxxxxxxxxxx
15806                                                         ldff1b.  */
15807                                                      return 1679;
15808                                                    }
15809                                                  else
15810                                                    {
15811                                                      /* 33222222222211111111110000000000
15812                                                         10987654321098765432109876543210
15813                                                         101001x0100xxxxx011xxxxxxxxxxxxx
15814                                                         ldff1sw.  */
15815                                                      return 1735;
15816                                                    }
15817                                                }
15818                                              else
15819                                                {
15820                                                  if (((word >> 23) & 0x1) == 0)
15821                                                    {
15822                                                      /* 33222222222211111111110000000000
15823                                                         10987654321098765432109876543210
15824                                                         101001x0010xxxxx011xxxxxxxxxxxxx
15825                                                         ldff1b.  */
15826                                                      return 1683;
15827                                                    }
15828                                                  else
15829                                                    {
15830                                                      /* 33222222222211111111110000000000
15831                                                         10987654321098765432109876543210
15832                                                         101001x0110xxxxx011xxxxxxxxxxxxx
15833                                                         ldff1h.  */
15834                                                      return 1702;
15835                                                    }
15836                                                }
15837                                            }
15838                                        }
15839                                    }
15840                                }
15841                              else
15842                                {
15843                                  if (((word >> 31) & 0x1) == 0)
15844                                    {
15845                                      /* 33222222222211111111110000000000
15846                                         10987654321098765432109876543210
15847                                         011001x0xx0xxxxx0xxxxxxxxxxxxxxx
15848                                         fcmla.  */
15849                                      return 1440;
15850                                    }
15851                                  else
15852                                    {
15853                                      if (((word >> 13) & 0x1) == 0)
15854                                        {
15855                                          if (((word >> 14) & 0x1) == 0)
15856                                            {
15857                                              if (((word >> 22) & 0x1) == 0)
15858                                                {
15859                                                  /* 33222222222211111111110000000000
15860                                                     10987654321098765432109876543210
15861                                                     111001x0x00xxxxx000xxxxxxxxxxxxx
15862                                                     st3q.  */
15863                                                  return 3318;
15864                                                }
15865                                              else
15866                                                {
15867                                                  if (((word >> 23) & 0x1) == 0)
15868                                                    {
15869                                                      /* 33222222222211111111110000000000
15870                                                         10987654321098765432109876543210
15871                                                         111001x0010xxxxx000xxxxxxxxxxxxx
15872                                                         st2q.  */
15873                                                      return 3317;
15874                                                    }
15875                                                  else
15876                                                    {
15877                                                      /* 33222222222211111111110000000000
15878                                                         10987654321098765432109876543210
15879                                                         111001x0110xxxxx000xxxxxxxxxxxxx
15880                                                         st4q.  */
15881                                                      return 3319;
15882                                                    }
15883                                                }
15884                                            }
15885                                          else
15886                                            {
15887                                              if (((word >> 22) & 0x1) == 0)
15888                                                {
15889                                                  /* 33222222222211111111110000000000
15890                                                     10987654321098765432109876543210
15891                                                     111001x0x00xxxxx010xxxxxxxxxxxxx
15892                                                     st1b.  */
15893                                                  return 1919;
15894                                                }
15895                                              else
15896                                                {
15897                                                  if (((word >> 23) & 0x1) == 0)
15898                                                    {
15899                                                      /* 33222222222211111111110000000000
15900                                                         10987654321098765432109876543210
15901                                                         111001x0010xxxxx010xxxxxxxxxxxxx
15902                                                         st1b.  */
15903                                                      return 1923;
15904                                                    }
15905                                                  else
15906                                                    {
15907                                                      /* 33222222222211111111110000000000
15908                                                         10987654321098765432109876543210
15909                                                         111001x0110xxxxx010xxxxxxxxxxxxx
15910                                                         st1h.  */
15911                                                      return 1944;
15912                                                    }
15913                                                }
15914                                            }
15915                                        }
15916                                      else
15917                                        {
15918                                          if (((word >> 14) & 0x1) == 0)
15919                                            {
15920                                              if (((word >> 22) & 0x1) == 0)
15921                                                {
15922                                                  if (((word >> 23) & 0x1) == 0)
15923                                                    {
15924                                                      /* 33222222222211111111110000000000
15925                                                         10987654321098765432109876543210
15926                                                         111001x0000xxxxx001xxxxxxxxxxxxx
15927                                                         stnt1b.  */
15928                                                      return 2297;
15929                                                    }
15930                                                  else
15931                                                    {
15932                                                      /* 33222222222211111111110000000000
15933                                                         10987654321098765432109876543210
15934                                                         111001x0100xxxxx001xxxxxxxxxxxxx
15935                                                         stnt1h.  */
15936                                                      return 2300;
15937                                                    }
15938                                                }
15939                                              else
15940                                                {
15941                                                  if (((word >> 23) & 0x1) == 0)
15942                                                    {
15943                                                      /* 33222222222211111111110000000000
15944                                                         10987654321098765432109876543210
15945                                                         111001x0010xxxxx001xxxxxxxxxxxxx
15946                                                         stnt1b.  */
15947                                                      return 2296;
15948                                                    }
15949                                                  else
15950                                                    {
15951                                                      /* 33222222222211111111110000000000
15952                                                         10987654321098765432109876543210
15953                                                         111001x0110xxxxx001xxxxxxxxxxxxx
15954                                                         stnt1h.  */
15955                                                      return 2299;
15956                                                    }
15957                                                }
15958                                            }
15959                                          else
15960                                            {
15961                                              if (((word >> 22) & 0x1) == 0)
15962                                                {
15963                                                  if (((word >> 23) & 0x1) == 0)
15964                                                    {
15965                                                      /* 33222222222211111111110000000000
15966                                                         10987654321098765432109876543210
15967                                                         111001x0000xxxxx011xxxxxxxxxxxxx
15968                                                         stnt1b.  */
15969                                                      return 1989;
15970                                                    }
15971                                                  else
15972                                                    {
15973                                                      /* 33222222222211111111110000000000
15974                                                         10987654321098765432109876543210
15975                                                         111001x0100xxxxx011xxxxxxxxxxxxx
15976                                                         stnt1h.  */
15977                                                      return 1993;
15978                                                    }
15979                                                }
15980                                              else
15981                                                {
15982                                                  if (((word >> 23) & 0x1) == 0)
15983                                                    {
15984                                                      /* 33222222222211111111110000000000
15985                                                         10987654321098765432109876543210
15986                                                         111001x0010xxxxx011xxxxxxxxxxxxx
15987                                                         st3b.  */
15988                                                      return 1973;
15989                                                    }
15990                                                  else
15991                                                    {
15992                                                      /* 33222222222211111111110000000000
15993                                                         10987654321098765432109876543210
15994                                                         111001x0110xxxxx011xxxxxxxxxxxxx
15995                                                         st3h.  */
15996                                                      return 1977;
15997                                                    }
15998                                                }
15999                                            }
16000                                        }
16001                                    }
16002                                }
16003                            }
16004                          else
16005                            {
16006                              if (((word >> 13) & 0x1) == 0)
16007                                {
16008                                  if (((word >> 30) & 0x1) == 0)
16009                                    {
16010                                      if (((word >> 14) & 0x1) == 0)
16011                                        {
16012                                          if (((word >> 4) & 0x1) == 0)
16013                                            {
16014                                              /* 33222222222211111111110000000000
16015                                                 10987654321098765432109876543210
16016                                                 x01001x0xx0xxxxx100xxxxxxxx0xxxx
16017                                                 cmpge.  */
16018                                              return 1375;
16019                                            }
16020                                          else
16021                                            {
16022                                              /* 33222222222211111111110000000000
16023                                                 10987654321098765432109876543210
16024                                                 x01001x0xx0xxxxx100xxxxxxxx1xxxx
16025                                                 cmpgt.  */
16026                                              return 1378;
16027                                            }
16028                                        }
16029                                      else
16030                                        {
16031                                          if (((word >> 31) & 0x1) == 0)
16032                                            {
16033                                              if (((word >> 4) & 0x1) == 0)
16034                                                {
16035                                                  /* 33222222222211111111110000000000
16036                                                     10987654321098765432109876543210
16037                                                     001001x0xx0xxxxx110xxxxxxxx0xxxx
16038                                                     cmphs.  */
16039                                                  return 1384;
16040                                                }
16041                                              else
16042                                                {
16043                                                  /* 33222222222211111111110000000000
16044                                                     10987654321098765432109876543210
16045                                                     001001x0xx0xxxxx110xxxxxxxx1xxxx
16046                                                     cmphi.  */
16047                                                  return 1381;
16048                                                }
16049                                            }
16050                                          else
16051                                            {
16052                                              if (((word >> 22) & 0x1) == 0)
16053                                                {
16054                                                  if (((word >> 23) & 0x1) == 0)
16055                                                    {
16056                                                      /* 33222222222211111111110000000000
16057                                                         10987654321098765432109876543210
16058                                                         101001x0000xxxxx110xxxxxxxxxxxxx
16059                                                         ldnt1b.  */
16060                                                      return 1770;
16061                                                    }
16062                                                  else
16063                                                    {
16064                                                      /* 33222222222211111111110000000000
16065                                                         10987654321098765432109876543210
16066                                                         101001x0100xxxxx110xxxxxxxxxxxxx
16067                                                         ldnt1h.  */
16068                                                      return 1774;
16069                                                    }
16070                                                }
16071                                              else
16072                                                {
16073                                                  if (((word >> 23) & 0x1) == 0)
16074                                                    {
16075                                                      /* 33222222222211111111110000000000
16076                                                         10987654321098765432109876543210
16077                                                         101001x0010xxxxx110xxxxxxxxxxxxx
16078                                                         ld3b.  */
16079                                                      return 1662;
16080                                                    }
16081                                                  else
16082                                                    {
16083                                                      /* 33222222222211111111110000000000
16084                                                         10987654321098765432109876543210
16085                                                         101001x0110xxxxx110xxxxxxxxxxxxx
16086                                                         ld3h.  */
16087                                                      return 1666;
16088                                                    }
16089                                                }
16090                                            }
16091                                        }
16092                                    }
16093                                  else
16094                                    {
16095                                      if (((word >> 31) & 0x1) == 0)
16096                                        {
16097                                          if (((word >> 17) & 0x1) == 0)
16098                                            {
16099                                              if (((word >> 18) & 0x1) == 0)
16100                                                {
16101                                                  if (((word >> 20) & 0x1) == 0)
16102                                                    {
16103                                                      /* 33222222222211111111110000000000
16104                                                         10987654321098765432109876543210
16105                                                         011001x0xx00x00x1x0xxxxxxxxxxxxx
16106                                                         fcadd.  */
16107                                                      return 1439;
16108                                                    }
16109                                                  else
16110                                                    {
16111                                                      /* 33222222222211111111110000000000
16112                                                         10987654321098765432109876543210
16113                                                         011001x0xx01x00x1x0xxxxxxxxxxxxx
16114                                                         faddp.  */
16115                                                      return 2123;
16116                                                    }
16117                                                }
16118                                              else
16119                                                {
16120                                                  if (((word >> 16) & 0x1) == 0)
16121                                                    {
16122                                                      /* 33222222222211111111110000000000
16123                                                         10987654321098765432109876543210
16124                                                         011001x0xx0xx1001x0xxxxxxxxxxxxx
16125                                                         fmaxnmp.  */
16126                                                      return 2131;
16127                                                    }
16128                                                  else
16129                                                    {
16130                                                      /* 33222222222211111111110000000000
16131                                                         10987654321098765432109876543210
16132                                                         011001x0xx0xx1011x0xxxxxxxxxxxxx
16133                                                         fminnmp.  */
16134                                                      return 2133;
16135                                                    }
16136                                                }
16137                                            }
16138                                          else
16139                                            {
16140                                              if (((word >> 16) & 0x1) == 0)
16141                                                {
16142                                                  /* 33222222222211111111110000000000
16143                                                     10987654321098765432109876543210
16144                                                     011001x0xx0xxx101x0xxxxxxxxxxxxx
16145                                                     fmaxp.  */
16146                                                  return 2132;
16147                                                }
16148                                              else
16149                                                {
16150                                                  /* 33222222222211111111110000000000
16151                                                     10987654321098765432109876543210
16152                                                     011001x0xx0xxx111x0xxxxxxxxxxxxx
16153                                                     fminp.  */
16154                                                  return 2134;
16155                                                }
16156                                            }
16157                                        }
16158                                      else
16159                                        {
16160                                          if (((word >> 22) & 0x1) == 0)
16161                                            {
16162                                              if (((word >> 23) & 0x1) == 0)
16163                                                {
16164                                                  /* 33222222222211111111110000000000
16165                                                     10987654321098765432109876543210
16166                                                     111001x0000xxxxx1x0xxxxxxxxxxxxx
16167                                                     st1b.  */
16168                                                  return 1920;
16169                                                }
16170                                              else
16171                                                {
16172                                                  /* 33222222222211111111110000000000
16173                                                     10987654321098765432109876543210
16174                                                     111001x0100xxxxx1x0xxxxxxxxxxxxx
16175                                                     st1h.  */
16176                                                  return 1939;
16177                                                }
16178                                            }
16179                                          else
16180                                            {
16181                                              if (((word >> 23) & 0x1) == 0)
16182                                                {
16183                                                  /* 33222222222211111111110000000000
16184                                                     10987654321098765432109876543210
16185                                                     111001x0010xxxxx1x0xxxxxxxxxxxxx
16186                                                     st1b.  */
16187                                                  return 1924;
16188                                                }
16189                                              else
16190                                                {
16191                                                  /* 33222222222211111111110000000000
16192                                                     10987654321098765432109876543210
16193                                                     111001x0110xxxxx1x0xxxxxxxxxxxxx
16194                                                     st1h.  */
16195                                                  return 1945;
16196                                                }
16197                                            }
16198                                        }
16199                                    }
16200                                }
16201                              else
16202                                {
16203                                  if (((word >> 14) & 0x1) == 0)
16204                                    {
16205                                      if (((word >> 30) & 0x1) == 0)
16206                                        {
16207                                          if (((word >> 31) & 0x1) == 0)
16208                                            {
16209                                              if (((word >> 4) & 0x1) == 0)
16210                                                {
16211                                                  /* 33222222222211111111110000000000
16212                                                     10987654321098765432109876543210
16213                                                     001001x0xx0xxxxx101xxxxxxxx0xxxx
16214                                                     cmpeq.  */
16215                                                  return 1372;
16216                                                }
16217                                              else
16218                                                {
16219                                                  /* 33222222222211111111110000000000
16220                                                     10987654321098765432109876543210
16221                                                     001001x0xx0xxxxx101xxxxxxxx1xxxx
16222                                                     cmpne.  */
16223                                                  return 1395;
16224                                                }
16225                                            }
16226                                          else
16227                                            {
16228                                              if (((word >> 20) & 0x1) == 0)
16229                                                {
16230                                                  if (((word >> 22) & 0x1) == 0)
16231                                                    {
16232                                                      if (((word >> 23) & 0x1) == 0)
16233                                                        {
16234                                                          /* 33222222222211111111110000000000
16235                                                             10987654321098765432109876543210
16236                                                             101001x00000xxxx101xxxxxxxxxxxxx
16237                                                             ld1b.  */
16238                                                          return 1562;
16239                                                        }
16240                                                      else
16241                                                        {
16242                                                          /* 33222222222211111111110000000000
16243                                                             10987654321098765432109876543210
16244                                                             101001x01000xxxx101xxxxxxxxxxxxx
16245                                                             ld1sw.  */
16246                                                          return 1640;
16247                                                        }
16248                                                    }
16249                                                  else
16250                                                    {
16251                                                      if (((word >> 23) & 0x1) == 0)
16252                                                        {
16253                                                          /* 33222222222211111111110000000000
16254                                                             10987654321098765432109876543210
16255                                                             101001x00100xxxx101xxxxxxxxxxxxx
16256                                                             ld1b.  */
16257                                                          return 1564;
16258                                                        }
16259                                                      else
16260                                                        {
16261                                                          /* 33222222222211111111110000000000
16262                                                             10987654321098765432109876543210
16263                                                             101001x01100xxxx101xxxxxxxxxxxxx
16264                                                             ld1h.  */
16265                                                          return 1585;
16266                                                        }
16267                                                    }
16268                                                }
16269                                              else
16270                                                {
16271                                                  if (((word >> 22) & 0x1) == 0)
16272                                                    {
16273                                                      if (((word >> 23) & 0x1) == 0)
16274                                                        {
16275                                                          /* 33222222222211111111110000000000
16276                                                             10987654321098765432109876543210
16277                                                             101001x00001xxxx101xxxxxxxxxxxxx
16278                                                             ldnf1b.  */
16279                                                          return 1754;
16280                                                        }
16281                                                      else
16282                                                        {
16283                                                          /* 33222222222211111111110000000000
16284                                                             10987654321098765432109876543210
16285                                                             101001x01001xxxx101xxxxxxxxxxxxx
16286                                                             ldnf1sw.  */
16287                                                          return 1767;
16288                                                        }
16289                                                    }
16290                                                  else
16291                                                    {
16292                                                      if (((word >> 23) & 0x1) == 0)
16293                                                        {
16294                                                          /* 33222222222211111111110000000000
16295                                                             10987654321098765432109876543210
16296                                                             101001x00101xxxx101xxxxxxxxxxxxx
16297                                                             ldnf1b.  */
16298                                                          return 1756;
16299                                                        }
16300                                                      else
16301                                                        {
16302                                                          /* 33222222222211111111110000000000
16303                                                             10987654321098765432109876543210
16304                                                             101001x01101xxxx101xxxxxxxxxxxxx
16305                                                             ldnf1h.  */
16306                                                          return 1760;
16307                                                        }
16308                                                    }
16309                                                }
16310                                            }
16311                                        }
16312                                      else
16313                                        {
16314                                          if (((word >> 31) & 0x1) == 0)
16315                                            {
16316                                              if (((word >> 16) & 0x1) == 0)
16317                                                {
16318                                                  if (((word >> 17) & 0x1) == 0)
16319                                                    {
16320                                                      if (((word >> 18) & 0x1) == 0)
16321                                                        {
16322                                                          if (((word >> 19) & 0x1) == 0)
16323                                                            {
16324                                                              /* 33222222222211111111110000000000
16325                                                                 10987654321098765432109876543210
16326                                                                 011001x0xx0x0000101xxxxxxxxxxxxx
16327                                                                 faddqv.  */
16328                                                              return 3302;
16329                                                            }
16330                                                          else
16331                                                            {
16332                                                              /* 33222222222211111111110000000000
16333                                                                 10987654321098765432109876543210
16334                                                                 011001x0xx0x1000101xxxxxxxxxxxxx
16335                                                                 fcvtnt.  */
16336                                                              return 2126;
16337                                                            }
16338                                                        }
16339                                                      else
16340                                                        {
16341                                                          /* 33222222222211111111110000000000
16342                                                             10987654321098765432109876543210
16343                                                             011001x0xx0xx100101xxxxxxxxxxxxx
16344                                                             fmaxnmqv.  */
16345                                                          return 3303;
16346                                                        }
16347                                                    }
16348                                                  else
16349                                                    {
16350                                                      if (((word >> 18) & 0x1) == 0)
16351                                                        {
16352                                                          if (((word >> 22) & 0x1) == 0)
16353                                                            {
16354                                                              if (((word >> 23) & 0x1) == 0)
16355                                                                {
16356                                                                  /* 33222222222211111111110000000000
16357                                                                     10987654321098765432109876543210
16358                                                                     011001x0000xx010101xxxxxxxxxxxxx
16359                                                                     fcvtxnt.  */
16360                                                                  return 2129;
16361                                                                }
16362                                                              else
16363                                                                {
16364                                                                  /* 33222222222211111111110000000000
16365                                                                     10987654321098765432109876543210
16366                                                                     011001x0100xx010101xxxxxxxxxxxxx
16367                                                                     bfcvtnt.  */
16368                                                                  return 3058;
16369                                                                }
16370                                                            }
16371                                                          else
16372                                                            {
16373                                                              /* 33222222222211111111110000000000
16374                                                                 10987654321098765432109876543210
16375                                                                 011001x0x10xx010101xxxxxxxxxxxxx
16376                                                                 fcvtnt.  */
16377                                                              return 2127;
16378                                                            }
16379                                                        }
16380                                                      else
16381                                                        {
16382                                                          /* 33222222222211111111110000000000
16383                                                             10987654321098765432109876543210
16384                                                             011001x0xx0xx110101xxxxxxxxxxxxx
16385                                                             fmaxqv.  */
16386                                                          return 3304;
16387                                                        }
16388                                                    }
16389                                                }
16390                                              else
16391                                                {
16392                                                  if (((word >> 17) & 0x1) == 0)
16393                                                    {
16394                                                      if (((word >> 18) & 0x1) == 0)
16395                                                        {
16396                                                          /* 33222222222211111111110000000000
16397                                                             10987654321098765432109876543210
16398                                                             011001x0xx0xx001101xxxxxxxxxxxxx
16399                                                             fcvtlt.  */
16400                                                          return 2124;
16401                                                        }
16402                                                      else
16403                                                        {
16404                                                          /* 33222222222211111111110000000000
16405                                                             10987654321098765432109876543210
16406                                                             011001x0xx0xx101101xxxxxxxxxxxxx
16407                                                             fminnmqv.  */
16408                                                          return 3305;
16409                                                        }
16410                                                    }
16411                                                  else
16412                                                    {
16413                                                      if (((word >> 18) & 0x1) == 0)
16414                                                        {
16415                                                          /* 33222222222211111111110000000000
16416                                                             10987654321098765432109876543210
16417                                                             011001x0xx0xx011101xxxxxxxxxxxxx
16418                                                             fcvtlt.  */
16419                                                          return 2125;
16420                                                        }
16421                                                      else
16422                                                        {
16423                                                          /* 33222222222211111111110000000000
16424                                                             10987654321098765432109876543210
16425                                                             011001x0xx0xx111101xxxxxxxxxxxxx
16426                                                             fminqv.  */
16427                                                          return 3306;
16428                                                        }
16429                                                    }
16430                                                }
16431                                            }
16432                                          else
16433                                            {
16434                                              if (((word >> 22) & 0x1) == 0)
16435                                                {
16436                                                  if (((word >> 23) & 0x1) == 0)
16437                                                    {
16438                                                      /* 33222222222211111111110000000000
16439                                                         10987654321098765432109876543210
16440                                                         111001x0000xxxxx101xxxxxxxxxxxxx
16441                                                         st1b.  */
16442                                                      return 1921;
16443                                                    }
16444                                                  else
16445                                                    {
16446                                                      /* 33222222222211111111110000000000
16447                                                         10987654321098765432109876543210
16448                                                         111001x0100xxxxx101xxxxxxxxxxxxx
16449                                                         st1h.  */
16450                                                      return 1940;
16451                                                    }
16452                                                }
16453                                              else
16454                                                {
16455                                                  if (((word >> 23) & 0x1) == 0)
16456                                                    {
16457                                                      /* 33222222222211111111110000000000
16458                                                         10987654321098765432109876543210
16459                                                         111001x0010xxxxx101xxxxxxxxxxxxx
16460                                                         st1b.  */
16461                                                      return 1928;
16462                                                    }
16463                                                  else
16464                                                    {
16465                                                      /* 33222222222211111111110000000000
16466                                                         10987654321098765432109876543210
16467                                                         111001x0110xxxxx101xxxxxxxxxxxxx
16468                                                         st1h.  */
16469                                                      return 1949;
16470                                                    }
16471                                                }
16472                                            }
16473                                        }
16474                                    }
16475                                  else
16476                                    {
16477                                      if (((word >> 30) & 0x1) == 0)
16478                                        {
16479                                          if (((word >> 31) & 0x1) == 0)
16480                                            {
16481                                              if (((word >> 4) & 0x1) == 0)
16482                                                {
16483                                                  /* 33222222222211111111110000000000
16484                                                     10987654321098765432109876543210
16485                                                     001001x0xx0xxxxx111xxxxxxxx0xxxx
16486                                                     cmplo.  */
16487                                                  return 1388;
16488                                                }
16489                                              else
16490                                                {
16491                                                  /* 33222222222211111111110000000000
16492                                                     10987654321098765432109876543210
16493                                                     001001x0xx0xxxxx111xxxxxxxx1xxxx
16494                                                     cmpls.  */
16495                                                  return 1390;
16496                                                }
16497                                            }
16498                                          else
16499                                            {
16500                                              if (((word >> 20) & 0x1) == 0)
16501                                                {
16502                                                  if (((word >> 22) & 0x1) == 0)
16503                                                    {
16504                                                      if (((word >> 23) & 0x1) == 0)
16505                                                        {
16506                                                          /* 33222222222211111111110000000000
16507                                                             10987654321098765432109876543210
16508                                                             101001x00000xxxx111xxxxxxxxxxxxx
16509                                                             ldnt1b.  */
16510                                                          return 1771;
16511                                                        }
16512                                                      else
16513                                                        {
16514                                                          /* 33222222222211111111110000000000
16515                                                             10987654321098765432109876543210
16516                                                             101001x01000xxxx111xxxxxxxxxxxxx
16517                                                             ldnt1h.  */
16518                                                          return 1775;
16519                                                        }
16520                                                    }
16521                                                  else
16522                                                    {
16523                                                      if (((word >> 23) & 0x1) == 0)
16524                                                        {
16525                                                          /* 33222222222211111111110000000000
16526                                                             10987654321098765432109876543210
16527                                                             101001x00100xxxx111xxxxxxxxxxxxx
16528                                                             ld3b.  */
16529                                                          return 1663;
16530                                                        }
16531                                                      else
16532                                                        {
16533                                                          /* 33222222222211111111110000000000
16534                                                             10987654321098765432109876543210
16535                                                             101001x01100xxxx111xxxxxxxxxxxxx
16536                                                             ld3h.  */
16537                                                          return 1667;
16538                                                        }
16539                                                    }
16540                                                }
16541                                              else
16542                                                {
16543                                                  /* 33222222222211111111110000000000
16544                                                     10987654321098765432109876543210
16545                                                     101001x0xx01xxxx111xxxxxxxxxxxxx
16546                                                     ld2q.  */
16547                                                  return 3310;
16548                                                }
16549                                            }
16550                                        }
16551                                      else
16552                                        {
16553                                          if (((word >> 20) & 0x1) == 0)
16554                                            {
16555                                              if (((word >> 22) & 0x1) == 0)
16556                                                {
16557                                                  /* 33222222222211111111110000000000
16558                                                     10987654321098765432109876543210
16559                                                     x11001x0x000xxxx111xxxxxxxxxxxxx
16560                                                     st1b.  */
16561                                                  return 1926;
16562                                                }
16563                                              else
16564                                                {
16565                                                  if (((word >> 23) & 0x1) == 0)
16566                                                    {
16567                                                      /* 33222222222211111111110000000000
16568                                                         10987654321098765432109876543210
16569                                                         x11001x00100xxxx111xxxxxxxxxxxxx
16570                                                         st1b.  */
16571                                                      return 1929;
16572                                                    }
16573                                                  else
16574                                                    {
16575                                                      /* 33222222222211111111110000000000
16576                                                         10987654321098765432109876543210
16577                                                         x11001x01100xxxx111xxxxxxxxxxxxx
16578                                                         st1h.  */
16579                                                      return 1950;
16580                                                    }
16581                                                }
16582                                            }
16583                                          else
16584                                            {
16585                                              if (((word >> 22) & 0x1) == 0)
16586                                                {
16587                                                  if (((word >> 23) & 0x1) == 0)
16588                                                    {
16589                                                      /* 33222222222211111111110000000000
16590                                                         10987654321098765432109876543210
16591                                                         x11001x00001xxxx111xxxxxxxxxxxxx
16592                                                         stnt1b.  */
16593                                                      return 1990;
16594                                                    }
16595                                                  else
16596                                                    {
16597                                                      /* 33222222222211111111110000000000
16598                                                         10987654321098765432109876543210
16599                                                         x11001x01001xxxx111xxxxxxxxxxxxx
16600                                                         stnt1h.  */
16601                                                      return 1994;
16602                                                    }
16603                                                }
16604                                              else
16605                                                {
16606                                                  if (((word >> 23) & 0x1) == 0)
16607                                                    {
16608                                                      /* 33222222222211111111110000000000
16609                                                         10987654321098765432109876543210
16610                                                         x11001x00101xxxx111xxxxxxxxxxxxx
16611                                                         st3b.  */
16612                                                      return 1974;
16613                                                    }
16614                                                  else
16615                                                    {
16616                                                      /* 33222222222211111111110000000000
16617                                                         10987654321098765432109876543210
16618                                                         x11001x01101xxxx111xxxxxxxxxxxxx
16619                                                         st3h.  */
16620                                                      return 1978;
16621                                                    }
16622                                                }
16623                                            }
16624                                        }
16625                                    }
16626                                }
16627                            }
16628                        }
16629                      else
16630                        {
16631                          if (((word >> 13) & 0x1) == 0)
16632                            {
16633                              if (((word >> 30) & 0x1) == 0)
16634                                {
16635                                  if (((word >> 31) & 0x1) == 0)
16636                                    {
16637                                      if (((word >> 4) & 0x1) == 0)
16638                                        {
16639                                          /* 33222222222211111111110000000000
16640                                             10987654321098765432109876543210
16641                                             001001x0xx1xxxxxxx0xxxxxxxx0xxxx
16642                                             cmphs.  */
16643                                          return 1385;
16644                                        }
16645                                      else
16646                                        {
16647                                          /* 33222222222211111111110000000000
16648                                             10987654321098765432109876543210
16649                                             001001x0xx1xxxxxxx0xxxxxxxx1xxxx
16650                                             cmphi.  */
16651                                          return 1382;
16652                                        }
16653                                    }
16654                                  else
16655                                    {
16656                                      if (((word >> 14) & 0x1) == 0)
16657                                        {
16658                                          if (((word >> 23) & 0x1) == 0)
16659                                            {
16660                                              /* 33222222222211111111110000000000
16661                                                 10987654321098765432109876543210
16662                                                 101001x00x1xxxxxx00xxxxxxxxxxxxx
16663                                                 ld1rob.  */
16664                                              return 3034;
16665                                            }
16666                                          else
16667                                            {
16668                                              /* 33222222222211111111110000000000
16669                                                 10987654321098765432109876543210
16670                                                 101001x01x1xxxxxx00xxxxxxxxxxxxx
16671                                                 ld1roh.  */
16672                                              return 3035;
16673                                            }
16674                                        }
16675                                      else
16676                                        {
16677                                          if (((word >> 15) & 0x1) == 0)
16678                                            {
16679                                              if (((word >> 22) & 0x1) == 0)
16680                                                {
16681                                                  if (((word >> 23) & 0x1) == 0)
16682                                                    {
16683                                                      /* 33222222222211111111110000000000
16684                                                         10987654321098765432109876543210
16685                                                         101001x0001xxxxx010xxxxxxxxxxxxx
16686                                                         ld1b.  */
16687                                                      return 1556;
16688                                                    }
16689                                                  else
16690                                                    {
16691                                                      /* 33222222222211111111110000000000
16692                                                         10987654321098765432109876543210
16693                                                         101001x0101xxxxx010xxxxxxxxxxxxx
16694                                                         ld1h.  */
16695                                                      return 1576;
16696                                                    }
16697                                                }
16698                                              else
16699                                                {
16700                                                  if (((word >> 23) & 0x1) == 0)
16701                                                    {
16702                                                      /* 33222222222211111111110000000000
16703                                                         10987654321098765432109876543210
16704                                                         101001x0011xxxxx010xxxxxxxxxxxxx
16705                                                         ld1b.  */
16706                                                      return 1558;
16707                                                    }
16708                                                  else
16709                                                    {
16710                                                      /* 33222222222211111111110000000000
16711                                                         10987654321098765432109876543210
16712                                                         101001x0111xxxxx010xxxxxxxxxxxxx
16713                                                         ld1h.  */
16714                                                      return 1578;
16715                                                    }
16716                                                }
16717                                            }
16718                                          else
16719                                            {
16720                                              if (((word >> 22) & 0x1) == 0)
16721                                                {
16722                                                  if (((word >> 23) & 0x1) == 0)
16723                                                    {
16724                                                      /* 33222222222211111111110000000000
16725                                                         10987654321098765432109876543210
16726                                                         101001x0001xxxxx110xxxxxxxxxxxxx
16727                                                         ld2b.  */
16728                                                      return 1654;
16729                                                    }
16730                                                  else
16731                                                    {
16732                                                      /* 33222222222211111111110000000000
16733                                                         10987654321098765432109876543210
16734                                                         101001x0101xxxxx110xxxxxxxxxxxxx
16735                                                         ld2h.  */
16736                                                      return 1658;
16737                                                    }
16738                                                }
16739                                              else
16740                                                {
16741                                                  if (((word >> 23) & 0x1) == 0)
16742                                                    {
16743                                                      /* 33222222222211111111110000000000
16744                                                         10987654321098765432109876543210
16745                                                         101001x0011xxxxx110xxxxxxxxxxxxx
16746                                                         ld4b.  */
16747                                                      return 1670;
16748                                                    }
16749                                                  else
16750                                                    {
16751                                                      /* 33222222222211111111110000000000
16752                                                         10987654321098765432109876543210
16753                                                         101001x0111xxxxx110xxxxxxxxxxxxx
16754                                                         ld4h.  */
16755                                                      return 1674;
16756                                                    }
16757                                                }
16758                                            }
16759                                        }
16760                                    }
16761                                }
16762                              else
16763                                {
16764                                  if (((word >> 15) & 0x1) == 0)
16765                                    {
16766                                      if (((word >> 14) & 0x1) == 0)
16767                                        {
16768                                          if (((word >> 23) & 0x1) == 0)
16769                                            {
16770                                              if (((word >> 31) & 0x1) == 0)
16771                                                {
16772                                                  if (((word >> 10) & 0x1) == 0)
16773                                                    {
16774                                                      if (((word >> 11) & 0x1) == 0)
16775                                                        {
16776                                                          /* 33222222222211111111110000000000
16777                                                             10987654321098765432109876543210
16778                                                             011001x00x1xxxxx000x00xxxxxxxxxx
16779                                                             fmla.  */
16780                                                          return 1493;
16781                                                        }
16782                                                      else
16783                                                        {
16784                                                          /* 33222222222211111111110000000000
16785                                                             10987654321098765432109876543210
16786                                                             011001x00x1xxxxx000x10xxxxxxxxxx
16787                                                             bfmla.  */
16788                                                          return 3284;
16789                                                        }
16790                                                    }
16791                                                  else
16792                                                    {
16793                                                      if (((word >> 11) & 0x1) == 0)
16794                                                        {
16795                                                          /* 33222222222211111111110000000000
16796                                                             10987654321098765432109876543210
16797                                                             011001x00x1xxxxx000x01xxxxxxxxxx
16798                                                             fmls.  */
16799                                                          return 1497;
16800                                                        }
16801                                                      else
16802                                                        {
16803                                                          /* 33222222222211111111110000000000
16804                                                             10987654321098765432109876543210
16805                                                             011001x00x1xxxxx000x11xxxxxxxxxx
16806                                                             bfmls.  */
16807                                                          return 3285;
16808                                                        }
16809                                                    }
16810                                                }
16811                                              else
16812                                                {
16813                                                  /* 33222222222211111111110000000000
16814                                                     10987654321098765432109876543210
16815                                                     111001x00x1xxxxx000xxxxxxxxxxxxx
16816                                                     st2q.  */
16817                                                  return 3320;
16818                                                }
16819                                            }
16820                                          else
16821                                            {
16822                                              if (((word >> 22) & 0x1) == 0)
16823                                                {
16824                                                  if (((word >> 31) & 0x1) == 0)
16825                                                    {
16826                                                      if (((word >> 12) & 0x1) == 0)
16827                                                        {
16828                                                          if (((word >> 10) & 0x1) == 0)
16829                                                            {
16830                                                              /* 33222222222211111111110000000000
16831                                                                 10987654321098765432109876543210
16832                                                                 011001x0101xxxxx0000x0xxxxxxxxxx
16833                                                                 fmla.  */
16834                                                              return 1494;
16835                                                            }
16836                                                          else
16837                                                            {
16838                                                              /* 33222222222211111111110000000000
16839                                                                 10987654321098765432109876543210
16840                                                                 011001x0101xxxxx0000x1xxxxxxxxxx
16841                                                                 fmls.  */
16842                                                              return 1498;
16843                                                            }
16844                                                        }
16845                                                      else
16846                                                        {
16847                                                          /* 33222222222211111111110000000000
16848                                                             10987654321098765432109876543210
16849                                                             011001x0101xxxxx0001xxxxxxxxxxxx
16850                                                             fcmla.  */
16851                                                          return 1441;
16852                                                        }
16853                                                    }
16854                                                  else
16855                                                    {
16856                                                      /* 33222222222211111111110000000000
16857                                                         10987654321098765432109876543210
16858                                                         111001x0101xxxxx000xxxxxxxxxxxxx
16859                                                         st3q.  */
16860                                                      return 3321;
16861                                                    }
16862                                                }
16863                                              else
16864                                                {
16865                                                  if (((word >> 31) & 0x1) == 0)
16866                                                    {
16867                                                      if (((word >> 12) & 0x1) == 0)
16868                                                        {
16869                                                          if (((word >> 10) & 0x1) == 0)
16870                                                            {
16871                                                              /* 33222222222211111111110000000000
16872                                                                 10987654321098765432109876543210
16873                                                                 011001x0111xxxxx0000x0xxxxxxxxxx
16874                                                                 fmla.  */
16875                                                              return 1495;
16876                                                            }
16877                                                          else
16878                                                            {
16879                                                              /* 33222222222211111111110000000000
16880                                                                 10987654321098765432109876543210
16881                                                                 011001x0111xxxxx0000x1xxxxxxxxxx
16882                                                                 fmls.  */
16883                                                              return 1499;
16884                                                            }
16885                                                        }
16886                                                      else
16887                                                        {
16888                                                          /* 33222222222211111111110000000000
16889                                                             10987654321098765432109876543210
16890                                                             011001x0111xxxxx0001xxxxxxxxxxxx
16891                                                             fcmla.  */
16892                                                          return 1442;
16893                                                        }
16894                                                    }
16895                                                  else
16896                                                    {
16897                                                      /* 33222222222211111111110000000000
16898                                                         10987654321098765432109876543210
16899                                                         111001x0111xxxxx000xxxxxxxxxxxxx
16900                                                         st4q.  */
16901                                                      return 3322;
16902                                                    }
16903                                                }
16904                                            }
16905                                        }
16906                                      else
16907                                        {
16908                                          if (((word >> 22) & 0x1) == 0)
16909                                            {
16910                                              if (((word >> 23) & 0x1) == 0)
16911                                                {
16912                                                  if (((word >> 31) & 0x1) == 0)
16913                                                    {
16914                                                      /* 33222222222211111111110000000000
16915                                                         10987654321098765432109876543210
16916                                                         011001x0001xxxxx010xxxxxxxxxxxxx
16917                                                         fdot.  */
16918                                                      return 2462;
16919                                                    }
16920                                                  else
16921                                                    {
16922                                                      /* 33222222222211111111110000000000
16923                                                         10987654321098765432109876543210
16924                                                         111001x0001xxxxx010xxxxxxxxxxxxx
16925                                                         st1b.  */
16926                                                      return 1922;
16927                                                    }
16928                                                }
16929                                              else
16930                                                {
16931                                                  if (((word >> 31) & 0x1) == 0)
16932                                                    {
16933                                                      if (((word >> 10) & 0x1) == 0)
16934                                                        {
16935                                                          /* 33222222222211111111110000000000
16936                                                             10987654321098765432109876543210
16937                                                             011001x0101xxxxx010xx0xxxxxxxxxx
16938                                                             fmlalb.  */
16939                                                          return 2135;
16940                                                        }
16941                                                      else
16942                                                        {
16943                                                          /* 33222222222211111111110000000000
16944                                                             10987654321098765432109876543210
16945                                                             011001x0101xxxxx010xx1xxxxxxxxxx
16946                                                             fmlalt.  */
16947                                                          return 2137;
16948                                                        }
16949                                                    }
16950                                                  else
16951                                                    {
16952                                                      /* 33222222222211111111110000000000
16953                                                         10987654321098765432109876543210
16954                                                         111001x0101xxxxx010xxxxxxxxxxxxx
16955                                                         st1h.  */
16956                                                      return 1941;
16957                                                    }
16958                                                }
16959                                            }
16960                                          else
16961                                            {
16962                                              if (((word >> 23) & 0x1) == 0)
16963                                                {
16964                                                  if (((word >> 31) & 0x1) == 0)
16965                                                    {
16966                                                      /* 33222222222211111111110000000000
16967                                                         10987654321098765432109876543210
16968                                                         011001x0011xxxxx010xxxxxxxxxxxxx
16969                                                         bfdot.  */
16970                                                      return 3055;
16971                                                    }
16972                                                  else
16973                                                    {
16974                                                      /* 33222222222211111111110000000000
16975                                                         10987654321098765432109876543210
16976                                                         111001x0011xxxxx010xxxxxxxxxxxxx
16977                                                         st1b.  */
16978                                                      return 1925;
16979                                                    }
16980                                                }
16981                                              else
16982                                                {
16983                                                  if (((word >> 31) & 0x1) == 0)
16984                                                    {
16985                                                      if (((word >> 10) & 0x1) == 0)
16986                                                        {
16987                                                          /* 33222222222211111111110000000000
16988                                                             10987654321098765432109876543210
16989                                                             011001x0111xxxxx010xx0xxxxxxxxxx
16990                                                             bfmlalb.  */
16991                                                          return 3062;
16992                                                        }
16993                                                      else
16994                                                        {
16995                                                          /* 33222222222211111111110000000000
16996                                                             10987654321098765432109876543210
16997                                                             011001x0111xxxxx010xx1xxxxxxxxxx
16998                                                             bfmlalt.  */
16999                                                          return 3061;
17000                                                        }
17001                                                    }
17002                                                  else
17003                                                    {
17004                                                      /* 33222222222211111111110000000000
17005                                                         10987654321098765432109876543210
17006                                                         111001x0111xxxxx010xxxxxxxxxxxxx
17007                                                         st1h.  */
17008                                                      return 1946;
17009                                                    }
17010                                                }
17011                                            }
17012                                        }
17013                                    }
17014                                  else
17015                                    {
17016                                      if (((word >> 22) & 0x1) == 0)
17017                                        {
17018                                          if (((word >> 23) & 0x1) == 0)
17019                                            {
17020                                              /* 33222222222211111111110000000000
17021                                                 10987654321098765432109876543210
17022                                                 x11001x0001xxxxx1x0xxxxxxxxxxxxx
17023                                                 fdot.  */
17024                                              return 2463;
17025                                            }
17026                                          else
17027                                            {
17028                                              if (((word >> 31) & 0x1) == 0)
17029                                                {
17030                                                  if (((word >> 10) & 0x1) == 0)
17031                                                    {
17032                                                      /* 33222222222211111111110000000000
17033                                                         10987654321098765432109876543210
17034                                                         011001x0101xxxxx1x0xx0xxxxxxxxxx
17035                                                         fmlalb.  */
17036                                                      return 2136;
17037                                                    }
17038                                                  else
17039                                                    {
17040                                                      /* 33222222222211111111110000000000
17041                                                         10987654321098765432109876543210
17042                                                         011001x0101xxxxx1x0xx1xxxxxxxxxx
17043                                                         fmlalt.  */
17044                                                      return 2138;
17045                                                    }
17046                                                }
17047                                              else
17048                                                {
17049                                                  /* 33222222222211111111110000000000
17050                                                     10987654321098765432109876543210
17051                                                     111001x0101xxxxx1x0xxxxxxxxxxxxx
17052                                                     st1h.  */
17053                                                  return 1942;
17054                                                }
17055                                            }
17056                                        }
17057                                      else
17058                                        {
17059                                          if (((word >> 23) & 0x1) == 0)
17060                                            {
17061                                              /* 33222222222211111111110000000000
17062                                                 10987654321098765432109876543210
17063                                                 x11001x0011xxxxx1x0xxxxxxxxxxxxx
17064                                                 bfdot.  */
17065                                              return 3054;
17066                                            }
17067                                          else
17068                                            {
17069                                              if (((word >> 31) & 0x1) == 0)
17070                                                {
17071                                                  if (((word >> 10) & 0x1) == 0)
17072                                                    {
17073                                                      /* 33222222222211111111110000000000
17074                                                         10987654321098765432109876543210
17075                                                         011001x0111xxxxx1x0xx0xxxxxxxxxx
17076                                                         bfmlalb.  */
17077                                                      return 3060;
17078                                                    }
17079                                                  else
17080                                                    {
17081                                                      /* 33222222222211111111110000000000
17082                                                         10987654321098765432109876543210
17083                                                         011001x0111xxxxx1x0xx1xxxxxxxxxx
17084                                                         bfmlalt.  */
17085                                                      return 3059;
17086                                                    }
17087                                                }
17088                                              else
17089                                                {
17090                                                  /* 33222222222211111111110000000000
17091                                                     10987654321098765432109876543210
17092                                                     111001x0111xxxxx1x0xxxxxxxxxxxxx
17093                                                     st1h.  */
17094                                                  return 1947;
17095                                                }
17096                                            }
17097                                        }
17098                                    }
17099                                }
17100                            }
17101                          else
17102                            {
17103                              if (((word >> 30) & 0x1) == 0)
17104                                {
17105                                  if (((word >> 31) & 0x1) == 0)
17106                                    {
17107                                      if (((word >> 4) & 0x1) == 0)
17108                                        {
17109                                          /* 33222222222211111111110000000000
17110                                             10987654321098765432109876543210
17111                                             001001x0xx1xxxxxxx1xxxxxxxx0xxxx
17112                                             cmplo.  */
17113                                          return 1389;
17114                                        }
17115                                      else
17116                                        {
17117                                          /* 33222222222211111111110000000000
17118                                             10987654321098765432109876543210
17119                                             001001x0xx1xxxxxxx1xxxxxxxx1xxxx
17120                                             cmpls.  */
17121                                          return 1391;
17122                                        }
17123                                    }
17124                                  else
17125                                    {
17126                                      if (((word >> 14) & 0x1) == 0)
17127                                        {
17128                                          if (((word >> 15) & 0x1) == 0)
17129                                            {
17130                                              if (((word >> 23) & 0x1) == 0)
17131                                                {
17132                                                  /* 33222222222211111111110000000000
17133                                                     10987654321098765432109876543210
17134                                                     101001x00x1xxxxx001xxxxxxxxxxxxx
17135                                                     ld1rob.  */
17136                                                  return 3038;
17137                                                }
17138                                              else
17139                                                {
17140                                                  /* 33222222222211111111110000000000
17141                                                     10987654321098765432109876543210
17142                                                     101001x01x1xxxxx001xxxxxxxxxxxxx
17143                                                     ld1roh.  */
17144                                                  return 3039;
17145                                                }
17146                                            }
17147                                          else
17148                                            {
17149                                              if (((word >> 20) & 0x1) == 0)
17150                                                {
17151                                                  if (((word >> 22) & 0x1) == 0)
17152                                                    {
17153                                                      if (((word >> 23) & 0x1) == 0)
17154                                                        {
17155                                                          /* 33222222222211111111110000000000
17156                                                             10987654321098765432109876543210
17157                                                             101001x00010xxxx101xxxxxxxxxxxxx
17158                                                             ld1b.  */
17159                                                          return 1563;
17160                                                        }
17161                                                      else
17162                                                        {
17163                                                          /* 33222222222211111111110000000000
17164                                                             10987654321098765432109876543210
17165                                                             101001x01010xxxx101xxxxxxxxxxxxx
17166                                                             ld1h.  */
17167                                                          return 1584;
17168                                                        }
17169                                                    }
17170                                                  else
17171                                                    {
17172                                                      if (((word >> 23) & 0x1) == 0)
17173                                                        {
17174                                                          /* 33222222222211111111110000000000
17175                                                             10987654321098765432109876543210
17176                                                             101001x00110xxxx101xxxxxxxxxxxxx
17177                                                             ld1b.  */
17178                                                          return 1565;
17179                                                        }
17180                                                      else
17181                                                        {
17182                                                          /* 33222222222211111111110000000000
17183                                                             10987654321098765432109876543210
17184                                                             101001x01110xxxx101xxxxxxxxxxxxx
17185                                                             ld1h.  */
17186                                                          return 1586;
17187                                                        }
17188                                                    }
17189                                                }
17190                                              else
17191                                                {
17192                                                  if (((word >> 22) & 0x1) == 0)
17193                                                    {
17194                                                      if (((word >> 23) & 0x1) == 0)
17195                                                        {
17196                                                          /* 33222222222211111111110000000000
17197                                                             10987654321098765432109876543210
17198                                                             101001x00011xxxx101xxxxxxxxxxxxx
17199                                                             ldnf1b.  */
17200                                                          return 1755;
17201                                                        }
17202                                                      else
17203                                                        {
17204                                                          /* 33222222222211111111110000000000
17205                                                             10987654321098765432109876543210
17206                                                             101001x01011xxxx101xxxxxxxxxxxxx
17207                                                             ldnf1h.  */
17208                                                          return 1759;
17209                                                        }
17210                                                    }
17211                                                  else
17212                                                    {
17213                                                      if (((word >> 23) & 0x1) == 0)
17214                                                        {
17215                                                          /* 33222222222211111111110000000000
17216                                                             10987654321098765432109876543210
17217                                                             101001x00111xxxx101xxxxxxxxxxxxx
17218                                                             ldnf1b.  */
17219                                                          return 1757;
17220                                                        }
17221                                                      else
17222                                                        {
17223                                                          /* 33222222222211111111110000000000
17224                                                             10987654321098765432109876543210
17225                                                             101001x01111xxxx101xxxxxxxxxxxxx
17226                                                             ldnf1h.  */
17227                                                          return 1761;
17228                                                        }
17229                                                    }
17230                                                }
17231                                            }
17232                                        }
17233                                      else
17234                                        {
17235                                          if (((word >> 15) & 0x1) == 0)
17236                                            {
17237                                              if (((word >> 22) & 0x1) == 0)
17238                                                {
17239                                                  if (((word >> 23) & 0x1) == 0)
17240                                                    {
17241                                                      /* 33222222222211111111110000000000
17242                                                         10987654321098765432109876543210
17243                                                         101001x0001xxxxx011xxxxxxxxxxxxx
17244                                                         ldff1b.  */
17245                                                      return 1681;
17246                                                    }
17247                                                  else
17248                                                    {
17249                                                      /* 33222222222211111111110000000000
17250                                                         10987654321098765432109876543210
17251                                                         101001x0101xxxxx011xxxxxxxxxxxxx
17252                                                         ldff1h.  */
17253                                                      return 1700;
17254                                                    }
17255                                                }
17256                                              else
17257                                                {
17258                                                  if (((word >> 23) & 0x1) == 0)
17259                                                    {
17260                                                      /* 33222222222211111111110000000000
17261                                                         10987654321098765432109876543210
17262                                                         101001x0011xxxxx011xxxxxxxxxxxxx
17263                                                         ldff1b.  */
17264                                                      return 1685;
17265                                                    }
17266                                                  else
17267                                                    {
17268                                                      /* 33222222222211111111110000000000
17269                                                         10987654321098765432109876543210
17270                                                         101001x0111xxxxx011xxxxxxxxxxxxx
17271                                                         ldff1h.  */
17272                                                      return 1704;
17273                                                    }
17274                                                }
17275                                            }
17276                                          else
17277                                            {
17278                                              if (((word >> 22) & 0x1) == 0)
17279                                                {
17280                                                  if (((word >> 23) & 0x1) == 0)
17281                                                    {
17282                                                      /* 33222222222211111111110000000000
17283                                                         10987654321098765432109876543210
17284                                                         101001x0001xxxxx111xxxxxxxxxxxxx
17285                                                         ld2b.  */
17286                                                      return 1655;
17287                                                    }
17288                                                  else
17289                                                    {
17290                                                      /* 33222222222211111111110000000000
17291                                                         10987654321098765432109876543210
17292                                                         101001x0101xxxxx111xxxxxxxxxxxxx
17293                                                         ld2h.  */
17294                                                      return 1659;
17295                                                    }
17296                                                }
17297                                              else
17298                                                {
17299                                                  if (((word >> 23) & 0x1) == 0)
17300                                                    {
17301                                                      /* 33222222222211111111110000000000
17302                                                         10987654321098765432109876543210
17303                                                         101001x0011xxxxx111xxxxxxxxxxxxx
17304                                                         ld4b.  */
17305                                                      return 1671;
17306                                                    }
17307                                                  else
17308                                                    {
17309                                                      /* 33222222222211111111110000000000
17310                                                         10987654321098765432109876543210
17311                                                         101001x0111xxxxx111xxxxxxxxxxxxx
17312                                                         ld4h.  */
17313                                                      return 1675;
17314                                                    }
17315                                                }
17316                                            }
17317                                        }
17318                                    }
17319                                }
17320                              else
17321                                {
17322                                  if (((word >> 14) & 0x1) == 0)
17323                                    {
17324                                      if (((word >> 15) & 0x1) == 0)
17325                                        {
17326                                          if (((word >> 31) & 0x1) == 0)
17327                                            {
17328                                              if (((word >> 10) & 0x1) == 0)
17329                                                {
17330                                                  if (((word >> 11) & 0x1) == 0)
17331                                                    {
17332                                                      if (((word >> 23) & 0x1) == 0)
17333                                                        {
17334                                                          /* 33222222222211111111110000000000
17335                                                             10987654321098765432109876543210
17336                                                             011001x00x1xxxxx001x00xxxxxxxxxx
17337                                                             fmul.  */
17338                                                          return 1504;
17339                                                        }
17340                                                      else
17341                                                        {
17342                                                          if (((word >> 22) & 0x1) == 0)
17343                                                            {
17344                                                              /* 33222222222211111111110000000000
17345                                                                 10987654321098765432109876543210
17346                                                                 011001x0101xxxxx001x00xxxxxxxxxx
17347                                                                 fmul.  */
17348                                                              return 1505;
17349                                                            }
17350                                                          else
17351                                                            {
17352                                                              /* 33222222222211111111110000000000
17353                                                                 10987654321098765432109876543210
17354                                                                 011001x0111xxxxx001x00xxxxxxxxxx
17355                                                                 fmul.  */
17356                                                              return 1506;
17357                                                            }
17358                                                        }
17359                                                    }
17360                                                  else
17361                                                    {
17362                                                      /* 33222222222211111111110000000000
17363                                                         10987654321098765432109876543210
17364                                                         011001x0xx1xxxxx001x10xxxxxxxxxx
17365                                                         bfmul.  */
17366                                                      return 3286;
17367                                                    }
17368                                                }
17369                                              else
17370                                                {
17371                                                  /* 33222222222211111111110000000000
17372                                                     10987654321098765432109876543210
17373                                                     011001x0xx1xxxxx001xx1xxxxxxxxxx
17374                                                     fclamp.  */
17375                                                  return 2464;
17376                                                }
17377                                            }
17378                                          else
17379                                            {
17380                                              /* 33222222222211111111110000000000
17381                                                 10987654321098765432109876543210
17382                                                 111001x0xx1xxxxx001xxxxxxxxxxxxx
17383                                                 st1q.  */
17384                                              return 3316;
17385                                            }
17386                                        }
17387                                      else
17388                                        {
17389                                          if (((word >> 22) & 0x1) == 0)
17390                                            {
17391                                              if (((word >> 31) & 0x1) == 0)
17392                                                {
17393                                                  if (((word >> 10) & 0x1) == 0)
17394                                                    {
17395                                                      /* 33222222222211111111110000000000
17396                                                         10987654321098765432109876543210
17397                                                         011001x0x01xxxxx101xx0xxxxxxxxxx
17398                                                         fmlslb.  */
17399                                                      return 2140;
17400                                                    }
17401                                                  else
17402                                                    {
17403                                                      /* 33222222222211111111110000000000
17404                                                         10987654321098765432109876543210
17405                                                         011001x0x01xxxxx101xx1xxxxxxxxxx
17406                                                         fmlslt.  */
17407                                                      return 2142;
17408                                                    }
17409                                                }
17410                                              else
17411                                                {
17412                                                  /* 33222222222211111111110000000000
17413                                                     10987654321098765432109876543210
17414                                                     111001x0x01xxxxx101xxxxxxxxxxxxx
17415                                                     st1h.  */
17416                                                  return 1943;
17417                                                }
17418                                            }
17419                                          else
17420                                            {
17421                                              if (((word >> 23) & 0x1) == 0)
17422                                                {
17423                                                  /* 33222222222211111111110000000000
17424                                                     10987654321098765432109876543210
17425                                                     x11001x0011xxxxx101xxxxxxxxxxxxx
17426                                                     st1b.  */
17427                                                  return 1930;
17428                                                }
17429                                              else
17430                                                {
17431                                                  if (((word >> 31) & 0x1) == 0)
17432                                                    {
17433                                                      if (((word >> 10) & 0x1) == 0)
17434                                                        {
17435                                                          /* 33222222222211111111110000000000
17436                                                             10987654321098765432109876543210
17437                                                             011001x0111xxxxx101xx0xxxxxxxxxx
17438                                                             bfmlslb.  */
17439                                                          return 2459;
17440                                                        }
17441                                                      else
17442                                                        {
17443                                                          /* 33222222222211111111110000000000
17444                                                             10987654321098765432109876543210
17445                                                             011001x0111xxxxx101xx1xxxxxxxxxx
17446                                                             bfmlslt.  */
17447                                                          return 2461;
17448                                                        }
17449                                                    }
17450                                                  else
17451                                                    {
17452                                                      /* 33222222222211111111110000000000
17453                                                         10987654321098765432109876543210
17454                                                         111001x0111xxxxx101xxxxxxxxxxxxx
17455                                                         st1h.  */
17456                                                      return 1951;
17457                                                    }
17458                                                }
17459                                            }
17460                                        }
17461                                    }
17462                                  else
17463                                    {
17464                                      if (((word >> 15) & 0x1) == 0)
17465                                        {
17466                                          if (((word >> 22) & 0x1) == 0)
17467                                            {
17468                                              if (((word >> 23) & 0x1) == 0)
17469                                                {
17470                                                  /* 33222222222211111111110000000000
17471                                                     10987654321098765432109876543210
17472                                                     x11001x0001xxxxx011xxxxxxxxxxxxx
17473                                                     st2b.  */
17474                                                  return 1965;
17475                                                }
17476                                              else
17477                                                {
17478                                                  if (((word >> 31) & 0x1) == 0)
17479                                                    {
17480                                                      if (((word >> 10) & 0x1) == 0)
17481                                                        {
17482                                                          /* 33222222222211111111110000000000
17483                                                             10987654321098765432109876543210
17484                                                             011001x0101xxxxx011xx0xxxxxxxxxx
17485                                                             fmlslb.  */
17486                                                          return 2139;
17487                                                        }
17488                                                      else
17489                                                        {
17490                                                          /* 33222222222211111111110000000000
17491                                                             10987654321098765432109876543210
17492                                                             011001x0101xxxxx011xx1xxxxxxxxxx
17493                                                             fmlslt.  */
17494                                                          return 2141;
17495                                                        }
17496                                                    }
17497                                                  else
17498                                                    {
17499                                                      /* 33222222222211111111110000000000
17500                                                         10987654321098765432109876543210
17501                                                         111001x0101xxxxx011xxxxxxxxxxxxx
17502                                                         st2h.  */
17503                                                      return 1969;
17504                                                    }
17505                                                }
17506                                            }
17507                                          else
17508                                            {
17509                                              if (((word >> 23) & 0x1) == 0)
17510                                                {
17511                                                  /* 33222222222211111111110000000000
17512                                                     10987654321098765432109876543210
17513                                                     x11001x0011xxxxx011xxxxxxxxxxxxx
17514                                                     st4b.  */
17515                                                  return 1981;
17516                                                }
17517                                              else
17518                                                {
17519                                                  if (((word >> 31) & 0x1) == 0)
17520                                                    {
17521                                                      if (((word >> 10) & 0x1) == 0)
17522                                                        {
17523                                                          /* 33222222222211111111110000000000
17524                                                             10987654321098765432109876543210
17525                                                             011001x0111xxxxx011xx0xxxxxxxxxx
17526                                                             bfmlslb.  */
17527                                                          return 2458;
17528                                                        }
17529                                                      else
17530                                                        {
17531                                                          /* 33222222222211111111110000000000
17532                                                             10987654321098765432109876543210
17533                                                             011001x0111xxxxx011xx1xxxxxxxxxx
17534                                                             bfmlslt.  */
17535                                                          return 2460;
17536                                                        }
17537                                                    }
17538                                                  else
17539                                                    {
17540                                                      /* 33222222222211111111110000000000
17541                                                         10987654321098765432109876543210
17542                                                         111001x0111xxxxx011xxxxxxxxxxxxx
17543                                                         st4h.  */
17544                                                      return 1985;
17545                                                    }
17546                                                }
17547                                            }
17548                                        }
17549                                      else
17550                                        {
17551                                          if (((word >> 22) & 0x1) == 0)
17552                                            {
17553                                              if (((word >> 23) & 0x1) == 0)
17554                                                {
17555                                                  if (((word >> 20) & 0x1) == 0)
17556                                                    {
17557                                                      /* 33222222222211111111110000000000
17558                                                         10987654321098765432109876543210
17559                                                         x11001x00010xxxx111xxxxxxxxxxxxx
17560                                                         st1b.  */
17561                                                      return 1927;
17562                                                    }
17563                                                  else
17564                                                    {
17565                                                      /* 33222222222211111111110000000000
17566                                                         10987654321098765432109876543210
17567                                                         x11001x00011xxxx111xxxxxxxxxxxxx
17568                                                         st2b.  */
17569                                                      return 1966;
17570                                                    }
17571                                                }
17572                                              else
17573                                                {
17574                                                  if (((word >> 31) & 0x1) == 0)
17575                                                    {
17576                                                      /* 33222222222211111111110000000000
17577                                                         10987654321098765432109876543210
17578                                                         011001x0101xxxxx111xxxxxxxxxxxxx
17579                                                         fmmla.  */
17580                                                      return 3032;
17581                                                    }
17582                                                  else
17583                                                    {
17584                                                      if (((word >> 20) & 0x1) == 0)
17585                                                        {
17586                                                          /* 33222222222211111111110000000000
17587                                                             10987654321098765432109876543210
17588                                                             111001x01010xxxx111xxxxxxxxxxxxx
17589                                                             st1h.  */
17590                                                          return 1948;
17591                                                        }
17592                                                      else
17593                                                        {
17594                                                          /* 33222222222211111111110000000000
17595                                                             10987654321098765432109876543210
17596                                                             111001x01011xxxx111xxxxxxxxxxxxx
17597                                                             st2h.  */
17598                                                          return 1970;
17599                                                        }
17600                                                    }
17601                                                }
17602                                            }
17603                                          else
17604                                            {
17605                                              if (((word >> 23) & 0x1) == 0)
17606                                                {
17607                                                  if (((word >> 31) & 0x1) == 0)
17608                                                    {
17609                                                      /* 33222222222211111111110000000000
17610                                                         10987654321098765432109876543210
17611                                                         011001x0011xxxxx111xxxxxxxxxxxxx
17612                                                         bfmmla.  */
17613                                                      return 3056;
17614                                                    }
17615                                                  else
17616                                                    {
17617                                                      if (((word >> 20) & 0x1) == 0)
17618                                                        {
17619                                                          /* 33222222222211111111110000000000
17620                                                             10987654321098765432109876543210
17621                                                             111001x00110xxxx111xxxxxxxxxxxxx
17622                                                             st1b.  */
17623                                                          return 1931;
17624                                                        }
17625                                                      else
17626                                                        {
17627                                                          /* 33222222222211111111110000000000
17628                                                             10987654321098765432109876543210
17629                                                             111001x00111xxxx111xxxxxxxxxxxxx
17630                                                             st4b.  */
17631                                                          return 1982;
17632                                                        }
17633                                                    }
17634                                                }
17635                                              else
17636                                                {
17637                                                  if (((word >> 31) & 0x1) == 0)
17638                                                    {
17639                                                      /* 33222222222211111111110000000000
17640                                                         10987654321098765432109876543210
17641                                                         011001x0111xxxxx111xxxxxxxxxxxxx
17642                                                         fmmla.  */
17643                                                      return 3033;
17644                                                    }
17645                                                  else
17646                                                    {
17647                                                      if (((word >> 20) & 0x1) == 0)
17648                                                        {
17649                                                          /* 33222222222211111111110000000000
17650                                                             10987654321098765432109876543210
17651                                                             111001x01110xxxx111xxxxxxxxxxxxx
17652                                                             st1h.  */
17653                                                          return 1952;
17654                                                        }
17655                                                      else
17656                                                        {
17657                                                          /* 33222222222211111111110000000000
17658                                                             10987654321098765432109876543210
17659                                                             111001x01111xxxx111xxxxxxxxxxxxx
17660                                                             st4h.  */
17661                                                          return 1986;
17662                                                        }
17663                                                    }
17664                                                }
17665                                            }
17666                                        }
17667                                    }
17668                                }
17669                            }
17670                        }
17671                    }
17672                }
17673              else
17674                {
17675                  if (((word >> 29) & 0x1) == 0)
17676                    {
17677                      if (((word >> 30) & 0x1) == 0)
17678                        {
17679                          if (((word >> 31) & 0x1) == 0)
17680                            {
17681                              if (((word >> 21) & 0x1) == 0)
17682                                {
17683                                  if (((word >> 20) & 0x1) == 0)
17684                                    {
17685                                      if (((word >> 22) & 0x1) == 0)
17686                                        {
17687                                          if (((word >> 23) & 0x1) == 0)
17688                                            {
17689                                              /* 33222222222211111111110000000000
17690                                                 10987654321098765432109876543210
17691                                                 000001x10000xxxxxxxxxxxxxxxxxxxx
17692                                                 orr.  */
17693                                              return 1810;
17694                                            }
17695                                          else
17696                                            {
17697                                              /* 33222222222211111111110000000000
17698                                                 10987654321098765432109876543210
17699                                                 000001x11000xxxxxxxxxxxxxxxxxxxx
17700                                                 and.  */
17701                                              return 1337;
17702                                            }
17703                                        }
17704                                      else
17705                                        {
17706                                          if (((word >> 23) & 0x1) == 0)
17707                                            {
17708                                              /* 33222222222211111111110000000000
17709                                                 10987654321098765432109876543210
17710                                                 000001x10100xxxxxxxxxxxxxxxxxxxx
17711                                                 eor.  */
17712                                              return 1424;
17713                                            }
17714                                          else
17715                                            {
17716                                              /* 33222222222211111111110000000000
17717                                                 10987654321098765432109876543210
17718                                                 000001x11100xxxxxxxxxxxxxxxxxxxx
17719                                                 dupm.  */
17720                                              return 1422;
17721                                            }
17722                                        }
17723                                    }
17724                                  else
17725                                    {
17726                                      if (((word >> 15) & 0x1) == 0)
17727                                        {
17728                                          /* 33222222222211111111110000000000
17729                                             10987654321098765432109876543210
17730                                             000001x1xx01xxxx0xxxxxxxxxxxxxxx
17731                                             cpy.  */
17732                                          return 1407;
17733                                        }
17734                                      else
17735                                        {
17736                                          /* 33222222222211111111110000000000
17737                                             10987654321098765432109876543210
17738                                             000001x1xx01xxxx1xxxxxxxxxxxxxxx
17739                                             fcpy.  */
17740                                          return 1454;
17741                                        }
17742                                    }
17743                                }
17744                              else
17745                                {
17746                                  if (((word >> 14) & 0x1) == 0)
17747                                    {
17748                                      if (((word >> 13) & 0x1) == 0)
17749                                        {
17750                                          if (((word >> 15) & 0x1) == 0)
17751                                            {
17752                                              if (((word >> 22) & 0x1) == 0)
17753                                                {
17754                                                  if (((word >> 23) & 0x1) == 0)
17755                                                    {
17756                                                      /* 33222222222211111111110000000000
17757                                                         10987654321098765432109876543210
17758                                                         000001x1001xxxxx000xxxxxxxxxxxxx
17759                                                         ext.  */
17760                                                      return 1429;
17761                                                    }
17762                                                  else
17763                                                    {
17764                                                      if (((word >> 10) & 0x1) == 0)
17765                                                        {
17766                                                          if (((word >> 11) & 0x1) == 0)
17767                                                            {
17768                                                              /* 33222222222211111111110000000000
17769                                                                 10987654321098765432109876543210
17770                                                                 000001x1101xxxxx000x00xxxxxxxxxx
17771                                                                 zip1.  */
17772                                                              return 3042;
17773                                                            }
17774                                                          else
17775                                                            {
17776                                                              if (((word >> 12) & 0x1) == 0)
17777                                                                {
17778                                                                  /* 33222222222211111111110000000000
17779                                                                     10987654321098765432109876543210
17780                                                                     000001x1101xxxxx000010xxxxxxxxxx
17781                                                                     uzp1.  */
17782                                                                  return 3044;
17783                                                                }
17784                                                              else
17785                                                                {
17786                                                                  /* 33222222222211111111110000000000
17787                                                                     10987654321098765432109876543210
17788                                                                     000001x1101xxxxx000110xxxxxxxxxx
17789                                                                     trn1.  */
17790                                                                  return 3046;
17791                                                                }
17792                                                            }
17793                                                        }
17794                                                      else
17795                                                        {
17796                                                          if (((word >> 11) & 0x1) == 0)
17797                                                            {
17798                                                              /* 33222222222211111111110000000000
17799                                                                 10987654321098765432109876543210
17800                                                                 000001x1101xxxxx000x01xxxxxxxxxx
17801                                                                 zip2.  */
17802                                                              return 3043;
17803                                                            }
17804                                                          else
17805                                                            {
17806                                                              if (((word >> 12) & 0x1) == 0)
17807                                                                {
17808                                                                  /* 33222222222211111111110000000000
17809                                                                     10987654321098765432109876543210
17810                                                                     000001x1101xxxxx000011xxxxxxxxxx
17811                                                                     uzp2.  */
17812                                                                  return 3045;
17813                                                                }
17814                                                              else
17815                                                                {
17816                                                                  /* 33222222222211111111110000000000
17817                                                                     10987654321098765432109876543210
17818                                                                     000001x1101xxxxx000111xxxxxxxxxx
17819                                                                     trn2.  */
17820                                                                  return 3047;
17821                                                                }
17822                                                            }
17823                                                        }
17824                                                    }
17825                                                }
17826                                              else
17827                                                {
17828                                                  /* 33222222222211111111110000000000
17829                                                     10987654321098765432109876543210
17830                                                     000001x1x11xxxxx000xxxxxxxxxxxxx
17831                                                     ext.  */
17832                                                  return 2122;
17833                                                }
17834                                            }
17835                                          else
17836                                            {
17837                                              if (((word >> 16) & 0x1) == 0)
17838                                                {
17839                                                  if (((word >> 17) & 0x1) == 0)
17840                                                    {
17841                                                      if (((word >> 18) & 0x1) == 0)
17842                                                        {
17843                                                          if (((word >> 19) & 0x1) == 0)
17844                                                            {
17845                                                              /* 33222222222211111111110000000000
17846                                                                 10987654321098765432109876543210
17847                                                                 000001x1xx1x0000100xxxxxxxxxxxxx
17848                                                                 cpy.  */
17849                                                              return 1405;
17850                                                            }
17851                                                          else
17852                                                            {
17853                                                              /* 33222222222211111111110000000000
17854                                                                 10987654321098765432109876543210
17855                                                                 000001x1xx1x1000100xxxxxxxxxxxxx
17856                                                                 clasta.  */
17857                                                              return 1363;
17858                                                            }
17859                                                        }
17860                                                      else
17861                                                        {
17862                                                          if (((word >> 19) & 0x1) == 0)
17863                                                            {
17864                                                              /* 33222222222211111111110000000000
17865                                                                 10987654321098765432109876543210
17866                                                                 000001x1xx1x0100100xxxxxxxxxxxxx
17867                                                                 revb.  */
17868                                                              return 1859;
17869                                                            }
17870                                                          else
17871                                                            {
17872                                                              /* 33222222222211111111110000000000
17873                                                                 10987654321098765432109876543210
17874                                                                 000001x1xx1x1100100xxxxxxxxxxxxx
17875                                                                 splice.  */
17876                                                              return 1886;
17877                                                            }
17878                                                        }
17879                                                    }
17880                                                  else
17881                                                    {
17882                                                      if (((word >> 18) & 0x1) == 0)
17883                                                        {
17884                                                          if (((word >> 19) & 0x1) == 0)
17885                                                            {
17886                                                              /* 33222222222211111111110000000000
17887                                                                 10987654321098765432109876543210
17888                                                                 000001x1xx1x0010100xxxxxxxxxxxxx
17889                                                                 lasta.  */
17890                                                              return 1551;
17891                                                            }
17892                                                          else
17893                                                            {
17894                                                              /* 33222222222211111111110000000000
17895                                                                 10987654321098765432109876543210
17896                                                                 000001x1xx1x1010100xxxxxxxxxxxxx
17897                                                                 clasta.  */
17898                                                              return 1364;
17899                                                            }
17900                                                        }
17901                                                      else
17902                                                        {
17903                                                          if (((word >> 19) & 0x1) == 0)
17904                                                            {
17905                                                              /* 33222222222211111111110000000000
17906                                                                 10987654321098765432109876543210
17907                                                                 000001x1xx1x0110100xxxxxxxxxxxxx
17908                                                                 revw.  */
17909                                                              return 1861;
17910                                                            }
17911                                                          else
17912                                                            {
17913                                                              /* 33222222222211111111110000000000
17914                                                                 10987654321098765432109876543210
17915                                                                 000001x1xx1x1110100xxxxxxxxxxxxx
17916                                                                 revd.  */
17917                                                              return 2452;
17918                                                            }
17919                                                        }
17920                                                    }
17921                                                }
17922                                              else
17923                                                {
17924                                                  if (((word >> 17) & 0x1) == 0)
17925                                                    {
17926                                                      if (((word >> 18) & 0x1) == 0)
17927                                                        {
17928                                                          if (((word >> 19) & 0x1) == 0)
17929                                                            {
17930                                                              /* 33222222222211111111110000000000
17931                                                                 10987654321098765432109876543210
17932                                                                 000001x1xx1x0001100xxxxxxxxxxxxx
17933                                                                 compact.  */
17934                                                              return 1404;
17935                                                            }
17936                                                          else
17937                                                            {
17938                                                              /* 33222222222211111111110000000000
17939                                                                 10987654321098765432109876543210
17940                                                                 000001x1xx1x1001100xxxxxxxxxxxxx
17941                                                                 clastb.  */
17942                                                              return 1366;
17943                                                            }
17944                                                        }
17945                                                      else
17946                                                        {
17947                                                          if (((word >> 19) & 0x1) == 0)
17948                                                            {
17949                                                              /* 33222222222211111111110000000000
17950                                                                 10987654321098765432109876543210
17951                                                                 000001x1xx1x0101100xxxxxxxxxxxxx
17952                                                                 revh.  */
17953                                                              return 1860;
17954                                                            }
17955                                                          else
17956                                                            {
17957                                                              /* 33222222222211111111110000000000
17958                                                                 10987654321098765432109876543210
17959                                                                 000001x1xx1x1101100xxxxxxxxxxxxx
17960                                                                 splice.  */
17961                                                              return 2217;
17962                                                            }
17963                                                        }
17964                                                    }
17965                                                  else
17966                                                    {
17967                                                      if (((word >> 18) & 0x1) == 0)
17968                                                        {
17969                                                          if (((word >> 19) & 0x1) == 0)
17970                                                            {
17971                                                              /* 33222222222211111111110000000000
17972                                                                 10987654321098765432109876543210
17973                                                                 000001x1xx1x0011100xxxxxxxxxxxxx
17974                                                                 lastb.  */
17975                                                              return 1553;
17976                                                            }
17977                                                          else
17978                                                            {
17979                                                              /* 33222222222211111111110000000000
17980                                                                 10987654321098765432109876543210
17981                                                                 000001x1xx1x1011100xxxxxxxxxxxxx
17982                                                                 clastb.  */
17983                                                              return 1367;
17984                                                            }
17985                                                        }
17986                                                      else
17987                                                        {
17988                                                          /* 33222222222211111111110000000000
17989                                                             10987654321098765432109876543210
17990                                                             000001x1xx1xx111100xxxxxxxxxxxxx
17991                                                             rbit.  */
17992                                                          return 1852;
17993                                                        }
17994                                                    }
17995                                                }
17996                                            }
17997                                        }
17998                                      else
17999                                        {
18000                                          if (((word >> 15) & 0x1) == 0)
18001                                            {
18002                                              if (((word >> 10) & 0x1) == 0)
18003                                                {
18004                                                  if (((word >> 11) & 0x1) == 0)
18005                                                    {
18006                                                      if (((word >> 12) & 0x1) == 0)
18007                                                        {
18008                                                          /* 33222222222211111111110000000000
18009                                                             10987654321098765432109876543210
18010                                                             000001x1xx1xxxxx001000xxxxxxxxxx
18011                                                             dup.  */
18012                                                          return 1420;
18013                                                        }
18014                                                      else
18015                                                        {
18016                                                          /* 33222222222211111111110000000000
18017                                                             10987654321098765432109876543210
18018                                                             000001x1xx1xxxxx001100xxxxxxxxxx
18019                                                             tbl.  */
18020                                                          return 2010;
18021                                                        }
18022                                                    }
18023                                                  else
18024                                                    {
18025                                                      if (((word >> 12) & 0x1) == 0)
18026                                                        {
18027                                                          /* 33222222222211111111110000000000
18028                                                             10987654321098765432109876543210
18029                                                             000001x1xx1xxxxx001010xxxxxxxxxx
18030                                                             tbl.  */
18031                                                          return 2306;
18032                                                        }
18033                                                      else
18034                                                        {
18035                                                          if (((word >> 16) & 0x1) == 0)
18036                                                            {
18037                                                              if (((word >> 17) & 0x1) == 0)
18038                                                                {
18039                                                                  if (((word >> 18) & 0x1) == 0)
18040                                                                    {
18041                                                                      if (((word >> 19) & 0x1) == 0)
18042                                                                        {
18043                                                                          if (((word >> 20) & 0x1) == 0)
18044                                                                            {
18045                                                                              /* 33222222222211111111110000000000
18046                                                                                 10987654321098765432109876543210
18047                                                                                 000001x1xx100000001110xxxxxxxxxx
18048                                                                                 dup.  */
18049                                                                              return 1419;
18050                                                                            }
18051                                                                          else
18052                                                                            {
18053                                                                              /* 33222222222211111111110000000000
18054                                                                                 10987654321098765432109876543210
18055                                                                                 000001x1xx110000001110xxxxxxxxxx
18056                                                                                 sunpklo.  */
18057                                                                              return 2006;
18058                                                                            }
18059                                                                        }
18060                                                                      else
18061                                                                        {
18062                                                                          /* 33222222222211111111110000000000
18063                                                                             10987654321098765432109876543210
18064                                                                             000001x1xx1x1000001110xxxxxxxxxx
18065                                                                             rev.  */
18066                                                                          return 1858;
18067                                                                        }
18068                                                                    }
18069                                                                  else
18070                                                                    {
18071                                                                      if (((word >> 20) & 0x1) == 0)
18072                                                                        {
18073                                                                          /* 33222222222211111111110000000000
18074                                                                             10987654321098765432109876543210
18075                                                                             000001x1xx10x100001110xxxxxxxxxx
18076                                                                             insr.  */
18077                                                                          return 1548;
18078                                                                        }
18079                                                                      else
18080                                                                        {
18081                                                                          /* 33222222222211111111110000000000
18082                                                                             10987654321098765432109876543210
18083                                                                             000001x1xx11x100001110xxxxxxxxxx
18084                                                                             insr.  */
18085                                                                          return 1549;
18086                                                                        }
18087                                                                    }
18088                                                                }
18089                                                              else
18090                                                                {
18091                                                                  /* 33222222222211111111110000000000
18092                                                                     10987654321098765432109876543210
18093                                                                     000001x1xx1xxx10001110xxxxxxxxxx
18094                                                                     uunpklo.  */
18095                                                                  return 2069;
18096                                                                }
18097                                                            }
18098                                                          else
18099                                                            {
18100                                                              if (((word >> 17) & 0x1) == 0)
18101                                                                {
18102                                                                  /* 33222222222211111111110000000000
18103                                                                     10987654321098765432109876543210
18104                                                                     000001x1xx1xxx01001110xxxxxxxxxx
18105                                                                     sunpkhi.  */
18106                                                                  return 2005;
18107                                                                }
18108                                                              else
18109                                                                {
18110                                                                  /* 33222222222211111111110000000000
18111                                                                     10987654321098765432109876543210
18112                                                                     000001x1xx1xxx11001110xxxxxxxxxx
18113                                                                     uunpkhi.  */
18114                                                                  return 2068;
18115                                                                }
18116                                                            }
18117                                                        }
18118                                                    }
18119                                                }
18120                                              else
18121                                                {
18122                                                  if (((word >> 11) & 0x1) == 0)
18123                                                    {
18124                                                      if (((word >> 22) & 0x1) == 0)
18125                                                        {
18126                                                          /* 33222222222211111111110000000000
18127                                                             10987654321098765432109876543210
18128                                                             000001x1x01xxxxx001x01xxxxxxxxxx
18129                                                             dupq.  */
18130                                                          return 3307;
18131                                                        }
18132                                                      else
18133                                                        {
18134                                                          /* 33222222222211111111110000000000
18135                                                             10987654321098765432109876543210
18136                                                             000001x1x11xxxxx001x01xxxxxxxxxx
18137                                                             extq.  */
18138                                                          return 3308;
18139                                                        }
18140                                                    }
18141                                                  else
18142                                                    {
18143                                                      /* 33222222222211111111110000000000
18144                                                         10987654321098765432109876543210
18145                                                         000001x1xx1xxxxx001x11xxxxxxxxxx
18146                                                         tbx.  */
18147                                                      return 2307;
18148                                                    }
18149                                                }
18150                                            }
18151                                          else
18152                                            {
18153                                              if (((word >> 16) & 0x1) == 0)
18154                                                {
18155                                                  if (((word >> 19) & 0x1) == 0)
18156                                                    {
18157                                                      if (((word >> 20) & 0x1) == 0)
18158                                                        {
18159                                                          /* 33222222222211111111110000000000
18160                                                             10987654321098765432109876543210
18161                                                             000001x1xx100xx0101xxxxxxxxxxxxx
18162                                                             lasta.  */
18163                                                          return 1550;
18164                                                        }
18165                                                      else
18166                                                        {
18167                                                          /* 33222222222211111111110000000000
18168                                                             10987654321098765432109876543210
18169                                                             000001x1xx110xx0101xxxxxxxxxxxxx
18170                                                             clasta.  */
18171                                                          return 1365;
18172                                                        }
18173                                                    }
18174                                                  else
18175                                                    {
18176                                                      /* 33222222222211111111110000000000
18177                                                         10987654321098765432109876543210
18178                                                         000001x1xx1x1xx0101xxxxxxxxxxxxx
18179                                                         cpy.  */
18180                                                      return 1406;
18181                                                    }
18182                                                }
18183                                              else
18184                                                {
18185                                                  if (((word >> 20) & 0x1) == 0)
18186                                                    {
18187                                                      /* 33222222222211111111110000000000
18188                                                         10987654321098765432109876543210
18189                                                         000001x1xx10xxx1101xxxxxxxxxxxxx
18190                                                         lastb.  */
18191                                                      return 1552;
18192                                                    }
18193                                                  else
18194                                                    {
18195                                                      /* 33222222222211111111110000000000
18196                                                         10987654321098765432109876543210
18197                                                         000001x1xx11xxx1101xxxxxxxxxxxxx
18198                                                         clastb.  */
18199                                                      return 1368;
18200                                                    }
18201                                                }
18202                                            }
18203                                        }
18204                                    }
18205                                  else
18206                                    {
18207                                      if (((word >> 15) & 0x1) == 0)
18208                                        {
18209                                          if (((word >> 10) & 0x1) == 0)
18210                                            {
18211                                              if (((word >> 11) & 0x1) == 0)
18212                                                {
18213                                                  if (((word >> 12) & 0x1) == 0)
18214                                                    {
18215                                                      if (((word >> 13) & 0x1) == 0)
18216                                                        {
18217                                                          if (((word >> 20) & 0x1) == 0)
18218                                                            {
18219                                                              /* 33222222222211111111110000000000
18220                                                                 10987654321098765432109876543210
18221                                                                 000001x1xx10xxxx010000xxxxxxxxxx
18222                                                                 zip1.  */
18223                                                              return 2086;
18224                                                            }
18225                                                          else
18226                                                            {
18227                                                              if (((word >> 16) & 0x1) == 0)
18228                                                                {
18229                                                                  if (((word >> 18) & 0x1) == 0)
18230                                                                    {
18231                                                                      /* 33222222222211111111110000000000
18232                                                                         10987654321098765432109876543210
18233                                                                         000001x1xx11x0x0010000xxxxxxxxxx
18234                                                                         punpklo.  */
18235                                                                      return 1851;
18236                                                                    }
18237                                                                  else
18238                                                                    {
18239                                                                      /* 33222222222211111111110000000000
18240                                                                         10987654321098765432109876543210
18241                                                                         000001x1xx11x1x0010000xxxxxxxxxx
18242                                                                         rev.  */
18243                                                                      return 1857;
18244                                                                    }
18245                                                                }
18246                                                              else
18247                                                                {
18248                                                                  /* 33222222222211111111110000000000
18249                                                                     10987654321098765432109876543210
18250                                                                     000001x1xx11xxx1010000xxxxxxxxxx
18251                                                                     punpkhi.  */
18252                                                                  return 1850;
18253                                                                }
18254                                                            }
18255                                                        }
18256                                                      else
18257                                                        {
18258                                                          /* 33222222222211111111110000000000
18259                                                             10987654321098765432109876543210
18260                                                             000001x1xx1xxxxx011000xxxxxxxxxx
18261                                                             zip1.  */
18262                                                          return 2087;
18263                                                        }
18264                                                    }
18265                                                  else
18266                                                    {
18267                                                      if (((word >> 13) & 0x1) == 0)
18268                                                        {
18269                                                          /* 33222222222211111111110000000000
18270                                                             10987654321098765432109876543210
18271                                                             000001x1xx1xxxxx010100xxxxxxxxxx
18272                                                             trn1.  */
18273                                                          return 2011;
18274                                                        }
18275                                                      else
18276                                                        {
18277                                                          /* 33222222222211111111110000000000
18278                                                             10987654321098765432109876543210
18279                                                             000001x1xx1xxxxx011100xxxxxxxxxx
18280                                                             trn1.  */
18281                                                          return 2012;
18282                                                        }
18283                                                    }
18284                                                }
18285                                              else
18286                                                {
18287                                                  if (((word >> 13) & 0x1) == 0)
18288                                                    {
18289                                                      /* 33222222222211111111110000000000
18290                                                         10987654321098765432109876543210
18291                                                         000001x1xx1xxxxx010x10xxxxxxxxxx
18292                                                         uzp1.  */
18293                                                      return 2073;
18294                                                    }
18295                                                  else
18296                                                    {
18297                                                      /* 33222222222211111111110000000000
18298                                                         10987654321098765432109876543210
18299                                                         000001x1xx1xxxxx011x10xxxxxxxxxx
18300                                                         uzp1.  */
18301                                                      return 2074;
18302                                                    }
18303                                                }
18304                                            }
18305                                          else
18306                                            {
18307                                              if (((word >> 11) & 0x1) == 0)
18308                                                {
18309                                                  if (((word >> 12) & 0x1) == 0)
18310                                                    {
18311                                                      if (((word >> 13) & 0x1) == 0)
18312                                                        {
18313                                                          /* 33222222222211111111110000000000
18314                                                             10987654321098765432109876543210
18315                                                             000001x1xx1xxxxx010001xxxxxxxxxx
18316                                                             zip2.  */
18317                                                          return 2088;
18318                                                        }
18319                                                      else
18320                                                        {
18321                                                          /* 33222222222211111111110000000000
18322                                                             10987654321098765432109876543210
18323                                                             000001x1xx1xxxxx011001xxxxxxxxxx
18324                                                             zip2.  */
18325                                                          return 2089;
18326                                                        }
18327                                                    }
18328                                                  else
18329                                                    {
18330                                                      if (((word >> 13) & 0x1) == 0)
18331                                                        {
18332                                                          /* 33222222222211111111110000000000
18333                                                             10987654321098765432109876543210
18334                                                             000001x1xx1xxxxx010101xxxxxxxxxx
18335                                                             trn2.  */
18336                                                          return 2013;
18337                                                        }
18338                                                      else
18339                                                        {
18340                                                          /* 33222222222211111111110000000000
18341                                                             10987654321098765432109876543210
18342                                                             000001x1xx1xxxxx011101xxxxxxxxxx
18343                                                             trn2.  */
18344                                                          return 2014;
18345                                                        }
18346                                                    }
18347                                                }
18348                                              else
18349                                                {
18350                                                  if (((word >> 13) & 0x1) == 0)
18351                                                    {
18352                                                      /* 33222222222211111111110000000000
18353                                                         10987654321098765432109876543210
18354                                                         000001x1xx1xxxxx010x11xxxxxxxxxx
18355                                                         uzp2.  */
18356                                                      return 2075;
18357                                                    }
18358                                                  else
18359                                                    {
18360                                                      /* 33222222222211111111110000000000
18361                                                         10987654321098765432109876543210
18362                                                         000001x1xx1xxxxx011x11xxxxxxxxxx
18363                                                         uzp2.  */
18364                                                      return 2076;
18365                                                    }
18366                                                }
18367                                            }
18368                                        }
18369                                      else
18370                                        {
18371                                          /* 33222222222211111111110000000000
18372                                             10987654321098765432109876543210
18373                                             000001x1xx1xxxxx11xxxxxxxxxxxxxx
18374                                             sel.  */
18375                                          return 1876;
18376                                        }
18377                                    }
18378                                }
18379                            }
18380                          else
18381                            {
18382                              if (((word >> 13) & 0x1) == 0)
18383                                {
18384                                  if (((word >> 14) & 0x1) == 0)
18385                                    {
18386                                      if (((word >> 15) & 0x1) == 0)
18387                                        {
18388                                          if (((word >> 22) & 0x1) == 0)
18389                                            {
18390                                              /* 33222222222211111111110000000000
18391                                                 10987654321098765432109876543210
18392                                                 100001x1x0xxxxxx000xxxxxxxxxxxxx
18393                                                 ldr.  */
18394                                              return 1778;
18395                                            }
18396                                          else
18397                                            {
18398                                              /* 33222222222211111111110000000000
18399                                                 10987654321098765432109876543210
18400                                                 100001x1x1xxxxxx000xxxxxxxxxxxxx
18401                                                 prfb.  */
18402                                              return 1824;
18403                                            }
18404                                        }
18405                                      else
18406                                        {
18407                                          if (((word >> 23) & 0x1) == 0)
18408                                            {
18409                                              /* 33222222222211111111110000000000
18410                                                 10987654321098765432109876543210
18411                                                 100001x10xxxxxxx100xxxxxxxxxxxxx
18412                                                 ld1rsh.  */
18413                                              return 1607;
18414                                            }
18415                                          else
18416                                            {
18417                                              /* 33222222222211111111110000000000
18418                                                 10987654321098765432109876543210
18419                                                 100001x11xxxxxxx100xxxxxxxxxxxxx
18420                                                 ld1rsb.  */
18421                                              return 1604;
18422                                            }
18423                                        }
18424                                    }
18425                                  else
18426                                    {
18427                                      if (((word >> 15) & 0x1) == 0)
18428                                        {
18429                                          if (((word >> 23) & 0x1) == 0)
18430                                            {
18431                                              if (((word >> 21) & 0x1) == 0)
18432                                                {
18433                                                  /* 33222222222211111111110000000000
18434                                                     10987654321098765432109876543210
18435                                                     100001x10x0xxxxx010xxxxxxxxxxxxx
18436                                                     ld1w.  */
18437                                                  return 1642;
18438                                                }
18439                                              else
18440                                                {
18441                                                  /* 33222222222211111111110000000000
18442                                                     10987654321098765432109876543210
18443                                                     100001x10x1xxxxx010xxxxxxxxxxxxx
18444                                                     ld1w.  */
18445                                                  return 1643;
18446                                                }
18447                                            }
18448                                          else
18449                                            {
18450                                              if (((word >> 22) & 0x1) == 0)
18451                                                {
18452                                                  /* 33222222222211111111110000000000
18453                                                     10987654321098765432109876543210
18454                                                     100001x110xxxxxx010xxxxxxxxxxxxx
18455                                                     ldr.  */
18456                                                  return 1780;
18457                                                }
18458                                              else
18459                                                {
18460                                                  /* 33222222222211111111110000000000
18461                                                     10987654321098765432109876543210
18462                                                     100001x111xxxxxx010xxxxxxxxxxxxx
18463                                                     prfw.  */
18464                                                  return 1845;
18465                                                }
18466                                            }
18467                                        }
18468                                      else
18469                                        {
18470                                          if (((word >> 22) & 0x1) == 0)
18471                                            {
18472                                              if (((word >> 21) & 0x1) == 0)
18473                                                {
18474                                                  if (((word >> 23) & 0x1) == 0)
18475                                                    {
18476                                                      /* 33222222222211111111110000000000
18477                                                         10987654321098765432109876543210
18478                                                         100001x1000xxxxx110xxxxxxxxxxxxx
18479                                                         prfw.  */
18480                                                      return 1841;
18481                                                    }
18482                                                  else
18483                                                    {
18484                                                      /* 33222222222211111111110000000000
18485                                                         10987654321098765432109876543210
18486                                                         100001x1100xxxxx110xxxxxxxxxxxxx
18487                                                         prfd.  */
18488                                                      return 1827;
18489                                                    }
18490                                                }
18491                                              else
18492                                                {
18493                                                  /* 33222222222211111111110000000000
18494                                                     10987654321098765432109876543210
18495                                                     100001x1x01xxxxx110xxxxxxxxxxxxx
18496                                                     ld1w.  */
18497                                                  return 1650;
18498                                                }
18499                                            }
18500                                          else
18501                                            {
18502                                              if (((word >> 23) & 0x1) == 0)
18503                                                {
18504                                                  /* 33222222222211111111110000000000
18505                                                     10987654321098765432109876543210
18506                                                     100001x101xxxxxx110xxxxxxxxxxxxx
18507                                                     ld1rw.  */
18508                                                  return 1610;
18509                                                }
18510                                              else
18511                                                {
18512                                                  /* 33222222222211111111110000000000
18513                                                     10987654321098765432109876543210
18514                                                     100001x111xxxxxx110xxxxxxxxxxxxx
18515                                                     ld1rsb.  */
18516                                                  return 1606;
18517                                                }
18518                                            }
18519                                        }
18520                                    }
18521                                }
18522                              else
18523                                {
18524                                  if (((word >> 14) & 0x1) == 0)
18525                                    {
18526                                      if (((word >> 15) & 0x1) == 0)
18527                                        {
18528                                          /* 33222222222211111111110000000000
18529                                             10987654321098765432109876543210
18530                                             100001x1xxxxxxxx001xxxxxxxxxxxxx
18531                                             prfh.  */
18532                                          return 1838;
18533                                        }
18534                                      else
18535                                        {
18536                                          if (((word >> 22) & 0x1) == 0)
18537                                            {
18538                                              /* 33222222222211111111110000000000
18539                                                 10987654321098765432109876543210
18540                                                 100001x1x0xxxxxx101xxxxxxxxxxxxx
18541                                                 ldnt1w.  */
18542                                              return 2153;
18543                                            }
18544                                          else
18545                                            {
18546                                              if (((word >> 23) & 0x1) == 0)
18547                                                {
18548                                                  /* 33222222222211111111110000000000
18549                                                     10987654321098765432109876543210
18550                                                     100001x101xxxxxx101xxxxxxxxxxxxx
18551                                                     ld1rsh.  */
18552                                                  return 1608;
18553                                                }
18554                                              else
18555                                                {
18556                                                  /* 33222222222211111111110000000000
18557                                                     10987654321098765432109876543210
18558                                                     100001x111xxxxxx101xxxxxxxxxxxxx
18559                                                     ld1rsb.  */
18560                                                  return 1605;
18561                                                }
18562                                            }
18563                                        }
18564                                    }
18565                                  else
18566                                    {
18567                                      if (((word >> 15) & 0x1) == 0)
18568                                        {
18569                                          if (((word >> 23) & 0x1) == 0)
18570                                            {
18571                                              if (((word >> 21) & 0x1) == 0)
18572                                                {
18573                                                  /* 33222222222211111111110000000000
18574                                                     10987654321098765432109876543210
18575                                                     100001x10x0xxxxx011xxxxxxxxxxxxx
18576                                                     ldff1w.  */
18577                                                  return 1742;
18578                                                }
18579                                              else
18580                                                {
18581                                                  /* 33222222222211111111110000000000
18582                                                     10987654321098765432109876543210
18583                                                     100001x10x1xxxxx011xxxxxxxxxxxxx
18584                                                     ldff1w.  */
18585                                                  return 1743;
18586                                                }
18587                                            }
18588                                          else
18589                                            {
18590                                              /* 33222222222211111111110000000000
18591                                                 10987654321098765432109876543210
18592                                                 100001x11xxxxxxx011xxxxxxxxxxxxx
18593                                                 prfd.  */
18594                                              return 1831;
18595                                            }
18596                                        }
18597                                      else
18598                                        {
18599                                          if (((word >> 22) & 0x1) == 0)
18600                                            {
18601                                              if (((word >> 21) & 0x1) == 0)
18602                                                {
18603                                                  if (((word >> 23) & 0x1) == 0)
18604                                                    {
18605                                                      /* 33222222222211111111110000000000
18606                                                         10987654321098765432109876543210
18607                                                         100001x1000xxxxx111xxxxxxxxxxxxx
18608                                                         prfw.  */
18609                                                      return 1844;
18610                                                    }
18611                                                  else
18612                                                    {
18613                                                      /* 33222222222211111111110000000000
18614                                                         10987654321098765432109876543210
18615                                                         100001x1100xxxxx111xxxxxxxxxxxxx
18616                                                         prfd.  */
18617                                                      return 1830;
18618                                                    }
18619                                                }
18620                                              else
18621                                                {
18622                                                  /* 33222222222211111111110000000000
18623                                                     10987654321098765432109876543210
18624                                                     100001x1x01xxxxx111xxxxxxxxxxxxx
18625                                                     ldff1w.  */
18626                                                  return 1752;
18627                                                }
18628                                            }
18629                                          else
18630                                            {
18631                                              if (((word >> 23) & 0x1) == 0)
18632                                                {
18633                                                  /* 33222222222211111111110000000000
18634                                                     10987654321098765432109876543210
18635                                                     100001x101xxxxxx111xxxxxxxxxxxxx
18636                                                     ld1rw.  */
18637                                                  return 1611;
18638                                                }
18639                                              else
18640                                                {
18641                                                  /* 33222222222211111111110000000000
18642                                                     10987654321098765432109876543210
18643                                                     100001x111xxxxxx111xxxxxxxxxxxxx
18644                                                     ld1rd.  */
18645                                                  return 1592;
18646                                                }
18647                                            }
18648                                        }
18649                                    }
18650                                }
18651                            }
18652                        }
18653                      else
18654                        {
18655                          if (((word >> 13) & 0x1) == 0)
18656                            {
18657                              if (((word >> 14) & 0x1) == 0)
18658                                {
18659                                  if (((word >> 15) & 0x1) == 0)
18660                                    {
18661                                      if (((word >> 21) & 0x1) == 0)
18662                                        {
18663                                          if (((word >> 31) & 0x1) == 0)
18664                                            {
18665                                              if (((word >> 10) & 0x1) == 0)
18666                                                {
18667                                                  if (((word >> 11) & 0x1) == 0)
18668                                                    {
18669                                                      if (((word >> 12) & 0x1) == 0)
18670                                                        {
18671                                                          /* 33222222222211111111110000000000
18672                                                             10987654321098765432109876543210
18673                                                             010001x1xx0xxxxx000000xxxxxxxxxx
18674                                                             saddlb.  */
18675                                                          return 2183;
18676                                                        }
18677                                                      else
18678                                                        {
18679                                                          /* 33222222222211111111110000000000
18680                                                             10987654321098765432109876543210
18681                                                             010001x1xx0xxxxx000100xxxxxxxxxx
18682                                                             ssublb.  */
18683                                                          return 2290;
18684                                                        }
18685                                                    }
18686                                                  else
18687                                                    {
18688                                                      if (((word >> 12) & 0x1) == 0)
18689                                                        {
18690                                                          /* 33222222222211111111110000000000
18691                                                             10987654321098765432109876543210
18692                                                             010001x1xx0xxxxx000010xxxxxxxxxx
18693                                                             uaddlb.  */
18694                                                          return 2314;
18695                                                        }
18696                                                      else
18697                                                        {
18698                                                          /* 33222222222211111111110000000000
18699                                                             10987654321098765432109876543210
18700                                                             010001x1xx0xxxxx000110xxxxxxxxxx
18701                                                             usublb.  */
18702                                                          return 2367;
18703                                                        }
18704                                                    }
18705                                                }
18706                                              else
18707                                                {
18708                                                  if (((word >> 11) & 0x1) == 0)
18709                                                    {
18710                                                      if (((word >> 12) & 0x1) == 0)
18711                                                        {
18712                                                          /* 33222222222211111111110000000000
18713                                                             10987654321098765432109876543210
18714                                                             010001x1xx0xxxxx000001xxxxxxxxxx
18715                                                             saddlt.  */
18716                                                          return 2185;
18717                                                        }
18718                                                      else
18719                                                        {
18720                                                          /* 33222222222211111111110000000000
18721                                                             10987654321098765432109876543210
18722                                                             010001x1xx0xxxxx000101xxxxxxxxxx
18723                                                             ssublt.  */
18724                                                          return 2292;
18725                                                        }
18726                                                    }
18727                                                  else
18728                                                    {
18729                                                      if (((word >> 12) & 0x1) == 0)
18730                                                        {
18731                                                          /* 33222222222211111111110000000000
18732                                                             10987654321098765432109876543210
18733                                                             010001x1xx0xxxxx000011xxxxxxxxxx
18734                                                             uaddlt.  */
18735                                                          return 2315;
18736                                                        }
18737                                                      else
18738                                                        {
18739                                                          /* 33222222222211111111110000000000
18740                                                             10987654321098765432109876543210
18741                                                             010001x1xx0xxxxx000111xxxxxxxxxx
18742                                                             usublt.  */
18743                                                          return 2368;
18744                                                        }
18745                                                    }
18746                                                }
18747                                            }
18748                                          else
18749                                            {
18750                                              /* 33222222222211111111110000000000
18751                                                 10987654321098765432109876543210
18752                                                 110001x1xx0xxxxx000xxxxxxxxxxxxx
18753                                                 ld1sw.  */
18754                                              return 1636;
18755                                            }
18756                                        }
18757                                      else
18758                                        {
18759                                          if (((word >> 23) & 0x1) == 0)
18760                                            {
18761                                              if (((word >> 31) & 0x1) == 0)
18762                                                {
18763                                                  if (((word >> 10) & 0x1) == 0)
18764                                                    {
18765                                                      if (((word >> 11) & 0x1) == 0)
18766                                                        {
18767                                                          if (((word >> 12) & 0x1) == 0)
18768                                                            {
18769                                                              /* 33222222222211111111110000000000
18770                                                                 10987654321098765432109876543210
18771                                                                 010001x10x1xxxxx000000xxxxxxxxxx
18772                                                                 sqshrunb.  */
18773                                                              return 2273;
18774                                                            }
18775                                                          else
18776                                                            {
18777                                                              /* 33222222222211111111110000000000
18778                                                                 10987654321098765432109876543210
18779                                                                 010001x10x1xxxxx000100xxxxxxxxxx
18780                                                                 shrnb.  */
18781                                                              return 2191;
18782                                                            }
18783                                                        }
18784                                                      else
18785                                                        {
18786                                                          if (((word >> 12) & 0x1) == 0)
18787                                                            {
18788                                                              /* 33222222222211111111110000000000
18789                                                                 10987654321098765432109876543210
18790                                                                 010001x10x1xxxxx000010xxxxxxxxxx
18791                                                                 sqrshrunb.  */
18792                                                              return 2265;
18793                                                            }
18794                                                          else
18795                                                            {
18796                                                              /* 33222222222211111111110000000000
18797                                                                 10987654321098765432109876543210
18798                                                                 010001x10x1xxxxx000110xxxxxxxxxx
18799                                                                 rshrnb.  */
18800                                                              return 2173;
18801                                                            }
18802                                                        }
18803                                                    }
18804                                                  else
18805                                                    {
18806                                                      if (((word >> 11) & 0x1) == 0)
18807                                                        {
18808                                                          if (((word >> 12) & 0x1) == 0)
18809                                                            {
18810                                                              /* 33222222222211111111110000000000
18811                                                                 10987654321098765432109876543210
18812                                                                 010001x10x1xxxxx000001xxxxxxxxxx
18813                                                                 sqshrunt.  */
18814                                                              return 2274;
18815                                                            }
18816                                                          else
18817                                                            {
18818                                                              /* 33222222222211111111110000000000
18819                                                                 10987654321098765432109876543210
18820                                                                 010001x10x1xxxxx000101xxxxxxxxxx
18821                                                                 shrnt.  */
18822                                                              return 2192;
18823                                                            }
18824                                                        }
18825                                                      else
18826                                                        {
18827                                                          if (((word >> 12) & 0x1) == 0)
18828                                                            {
18829                                                              /* 33222222222211111111110000000000
18830                                                                 10987654321098765432109876543210
18831                                                                 010001x10x1xxxxx000011xxxxxxxxxx
18832                                                                 sqrshrunt.  */
18833                                                              return 2266;
18834                                                            }
18835                                                          else
18836                                                            {
18837                                                              /* 33222222222211111111110000000000
18838                                                                 10987654321098765432109876543210
18839                                                                 010001x10x1xxxxx000111xxxxxxxxxx
18840                                                                 rshrnt.  */
18841                                                              return 2174;
18842                                                            }
18843                                                        }
18844                                                    }
18845                                                }
18846                                              else
18847                                                {
18848                                                  /* 33222222222211111111110000000000
18849                                                     10987654321098765432109876543210
18850                                                     110001x10x1xxxxx000xxxxxxxxxxxxx
18851                                                     ld1sw.  */
18852                                                  return 1637;
18853                                                }
18854                                            }
18855                                          else
18856                                            {
18857                                              /* 33222222222211111111110000000000
18858                                                 10987654321098765432109876543210
18859                                                 x10001x11x1xxxxx000xxxxxxxxxxxxx
18860                                                 sqrshrun.  */
18861                                              return 2470;
18862                                            }
18863                                        }
18864                                    }
18865                                  else
18866                                    {
18867                                      if (((word >> 21) & 0x1) == 0)
18868                                        {
18869                                          if (((word >> 31) & 0x1) == 0)
18870                                            {
18871                                              if (((word >> 10) & 0x1) == 0)
18872                                                {
18873                                                  if (((word >> 11) & 0x1) == 0)
18874                                                    {
18875                                                      if (((word >> 12) & 0x1) == 0)
18876                                                        {
18877                                                          /* 33222222222211111111110000000000
18878                                                             10987654321098765432109876543210
18879                                                             010001x1xx0xxxxx100000xxxxxxxxxx
18880                                                             saddlbt.  */
18881                                                          return 2184;
18882                                                        }
18883                                                      else
18884                                                        {
18885                                                          /* 33222222222211111111110000000000
18886                                                             10987654321098765432109876543210
18887                                                             010001x1xx0xxxxx100100xxxxxxxxxx
18888                                                             eorbt.  */
18889                                                          return 2120;
18890                                                        }
18891                                                    }
18892                                                  else
18893                                                    {
18894                                                      if (((word >> 12) & 0x1) == 0)
18895                                                        {
18896                                                          /* 33222222222211111111110000000000
18897                                                             10987654321098765432109876543210
18898                                                             010001x1xx0xxxxx100010xxxxxxxxxx
18899                                                             ssublbt.  */
18900                                                          return 2291;
18901                                                        }
18902                                                      else
18903                                                        {
18904                                                          if (((word >> 22) & 0x1) == 0)
18905                                                            {
18906                                                              if (((word >> 23) & 0x1) == 0)
18907                                                                {
18908                                                                  /* 33222222222211111111110000000000
18909                                                                     10987654321098765432109876543210
18910                                                                     010001x1000xxxxx100110xxxxxxxxxx
18911                                                                     smmla.  */
18912                                                                  return 3026;
18913                                                                }
18914                                                              else
18915                                                                {
18916                                                                  /* 33222222222211111111110000000000
18917                                                                     10987654321098765432109876543210
18918                                                                     010001x1100xxxxx100110xxxxxxxxxx
18919                                                                     usmmla.  */
18920                                                                  return 3028;
18921                                                                }
18922                                                            }
18923                                                          else
18924                                                            {
18925                                                              /* 33222222222211111111110000000000
18926                                                                 10987654321098765432109876543210
18927                                                                 010001x1x10xxxxx100110xxxxxxxxxx
18928                                                                 ummla.  */
18929                                                              return 3027;
18930                                                            }
18931                                                        }
18932                                                    }
18933                                                }
18934                                              else
18935                                                {
18936                                                  if (((word >> 11) & 0x1) == 0)
18937                                                    {
18938                                                      /* 33222222222211111111110000000000
18939                                                         10987654321098765432109876543210
18940                                                         010001x1xx0xxxxx100x01xxxxxxxxxx
18941                                                         eortb.  */
18942                                                      return 2121;
18943                                                    }
18944                                                  else
18945                                                    {
18946                                                      /* 33222222222211111111110000000000
18947                                                         10987654321098765432109876543210
18948                                                         010001x1xx0xxxxx100x11xxxxxxxxxx
18949                                                         ssubltb.  */
18950                                                      return 2293;
18951                                                    }
18952                                                }
18953                                            }
18954                                          else
18955                                            {
18956                                              if (((word >> 22) & 0x1) == 0)
18957                                                {
18958                                                  /* 33222222222211111111110000000000
18959                                                     10987654321098765432109876543210
18960                                                     110001x1x00xxxxx100xxxxxxxxxxxxx
18961                                                     ldnt1sw.  */
18962                                                  return 2152;
18963                                                }
18964                                              else
18965                                                {
18966                                                  /* 33222222222211111111110000000000
18967                                                     10987654321098765432109876543210
18968                                                     110001x1x10xxxxx100xxxxxxxxxxxxx
18969                                                     ld1sw.  */
18970                                                  return 1638;
18971                                                }
18972                                            }
18973                                        }
18974                                      else
18975                                        {
18976                                          if (((word >> 31) & 0x1) == 0)
18977                                            {
18978                                              if (((word >> 4) & 0x1) == 0)
18979                                                {
18980                                                  /* 33222222222211111111110000000000
18981                                                     10987654321098765432109876543210
18982                                                     010001x1xx1xxxxx100xxxxxxxx0xxxx
18983                                                     match.  */
18984                                                  return 2155;
18985                                                }
18986                                              else
18987                                                {
18988                                                  /* 33222222222211111111110000000000
18989                                                     10987654321098765432109876543210
18990                                                     010001x1xx1xxxxx100xxxxxxxx1xxxx
18991                                                     nmatch.  */
18992                                                  return 2167;
18993                                                }
18994                                            }
18995                                          else
18996                                            {
18997                                              if (((word >> 22) & 0x1) == 0)
18998                                                {
18999                                                  /* 33222222222211111111110000000000
19000                                                     10987654321098765432109876543210
19001                                                     110001x1x01xxxxx100xxxxxxxxxxxxx
19002                                                     ld1sw.  */
19003                                                  return 1641;
19004                                                }
19005                                              else
19006                                                {
19007                                                  /* 33222222222211111111110000000000
19008                                                     10987654321098765432109876543210
19009                                                     110001x1x11xxxxx100xxxxxxxxxxxxx
19010                                                     ld1sw.  */
19011                                                  return 1639;
19012                                                }
19013                                            }
19014                                        }
19015                                    }
19016                                }
19017                              else
19018                                {
19019                                  if (((word >> 15) & 0x1) == 0)
19020                                    {
19021                                      if (((word >> 21) & 0x1) == 0)
19022                                        {
19023                                          if (((word >> 31) & 0x1) == 0)
19024                                            {
19025                                              if (((word >> 10) & 0x1) == 0)
19026                                                {
19027                                                  if (((word >> 11) & 0x1) == 0)
19028                                                    {
19029                                                      if (((word >> 12) & 0x1) == 0)
19030                                                        {
19031                                                          /* 33222222222211111111110000000000
19032                                                             10987654321098765432109876543210
19033                                                             010001x1xx0xxxxx010000xxxxxxxxxx
19034                                                             saddwb.  */
19035                                                          return 2186;
19036                                                        }
19037                                                      else
19038                                                        {
19039                                                          /* 33222222222211111111110000000000
19040                                                             10987654321098765432109876543210
19041                                                             010001x1xx0xxxxx010100xxxxxxxxxx
19042                                                             ssubwb.  */
19043                                                          return 2294;
19044                                                        }
19045                                                    }
19046                                                  else
19047                                                    {
19048                                                      if (((word >> 12) & 0x1) == 0)
19049                                                        {
19050                                                          /* 33222222222211111111110000000000
19051                                                             10987654321098765432109876543210
19052                                                             010001x1xx0xxxxx010010xxxxxxxxxx
19053                                                             uaddwb.  */
19054                                                          return 2316;
19055                                                        }
19056                                                      else
19057                                                        {
19058                                                          /* 33222222222211111111110000000000
19059                                                             10987654321098765432109876543210
19060                                                             010001x1xx0xxxxx010110xxxxxxxxxx
19061                                                             usubwb.  */
19062                                                          return 2369;
19063                                                        }
19064                                                    }
19065                                                }
19066                                              else
19067                                                {
19068                                                  if (((word >> 11) & 0x1) == 0)
19069                                                    {
19070                                                      if (((word >> 12) & 0x1) == 0)
19071                                                        {
19072                                                          /* 33222222222211111111110000000000
19073                                                             10987654321098765432109876543210
19074                                                             010001x1xx0xxxxx010001xxxxxxxxxx
19075                                                             saddwt.  */
19076                                                          return 2187;
19077                                                        }
19078                                                      else
19079                                                        {
19080                                                          /* 33222222222211111111110000000000
19081                                                             10987654321098765432109876543210
19082                                                             010001x1xx0xxxxx010101xxxxxxxxxx
19083                                                             ssubwt.  */
19084                                                          return 2295;
19085                                                        }
19086                                                    }
19087                                                  else
19088                                                    {
19089                                                      if (((word >> 12) & 0x1) == 0)
19090                                                        {
19091                                                          /* 33222222222211111111110000000000
19092                                                             10987654321098765432109876543210
19093                                                             010001x1xx0xxxxx010011xxxxxxxxxx
19094                                                             uaddwt.  */
19095                                                          return 2317;
19096                                                        }
19097                                                      else
19098                                                        {
19099                                                          /* 33222222222211111111110000000000
19100                                                             10987654321098765432109876543210
19101                                                             010001x1xx0xxxxx010111xxxxxxxxxx
19102                                                             usubwt.  */
19103                                                          return 2370;
19104                                                        }
19105                                                    }
19106                                                }
19107                                            }
19108                                          else
19109                                            {
19110                                              if (((word >> 23) & 0x1) == 0)
19111                                                {
19112                                                  /* 33222222222211111111110000000000
19113                                                     10987654321098765432109876543210
19114                                                     110001x10x0xxxxx010xxxxxxxxxxxxx
19115                                                     ld1w.  */
19116                                                  return 1646;
19117                                                }
19118                                              else
19119                                                {
19120                                                  /* 33222222222211111111110000000000
19121                                                     10987654321098765432109876543210
19122                                                     110001x11x0xxxxx010xxxxxxxxxxxxx
19123                                                     ld1d.  */
19124                                                  return 1568;
19125                                                }
19126                                            }
19127                                        }
19128                                      else
19129                                        {
19130                                          if (((word >> 23) & 0x1) == 0)
19131                                            {
19132                                              if (((word >> 31) & 0x1) == 0)
19133                                                {
19134                                                  if (((word >> 10) & 0x1) == 0)
19135                                                    {
19136                                                      if (((word >> 11) & 0x1) == 0)
19137                                                        {
19138                                                          if (((word >> 12) & 0x1) == 0)
19139                                                            {
19140                                                              if (((word >> 16) & 0x1) == 0)
19141                                                                {
19142                                                                  /* 33222222222211111111110000000000
19143                                                                     10987654321098765432109876543210
19144                                                                     010001x10x1xxxx0010000xxxxxxxxxx
19145                                                                     sqxtnb.  */
19146                                                                  return 2277;
19147                                                                }
19148                                                              else
19149                                                                {
19150                                                                  /* 33222222222211111111110000000000
19151                                                                     10987654321098765432109876543210
19152                                                                     010001x10x1xxxx1010000xxxxxxxxxx
19153                                                                     sqcvtn.  */
19154                                                                  return 2467;
19155                                                                }
19156                                                            }
19157                                                          else
19158                                                            {
19159                                                              if (((word >> 16) & 0x1) == 0)
19160                                                                {
19161                                                                  /* 33222222222211111111110000000000
19162                                                                     10987654321098765432109876543210
19163                                                                     010001x10x1xxxx0010100xxxxxxxxxx
19164                                                                     sqxtunb.  */
19165                                                                  return 2279;
19166                                                                }
19167                                                              else
19168                                                                {
19169                                                                  /* 33222222222211111111110000000000
19170                                                                     10987654321098765432109876543210
19171                                                                     010001x10x1xxxx1010100xxxxxxxxxx
19172                                                                     sqcvtun.  */
19173                                                                  return 2468;
19174                                                                }
19175                                                            }
19176                                                        }
19177                                                      else
19178                                                        {
19179                                                          if (((word >> 16) & 0x1) == 0)
19180                                                            {
19181                                                              /* 33222222222211111111110000000000
19182                                                                 10987654321098765432109876543210
19183                                                                 010001x10x1xxxx0010x10xxxxxxxxxx
19184                                                                 uqxtnb.  */
19185                                                              return 2354;
19186                                                            }
19187                                                          else
19188                                                            {
19189                                                              /* 33222222222211111111110000000000
19190                                                                 10987654321098765432109876543210
19191                                                                 010001x10x1xxxx1010x10xxxxxxxxxx
19192                                                                 uqcvtn.  */
19193                                                              return 2473;
19194                                                            }
19195                                                        }
19196                                                    }
19197                                                  else
19198                                                    {
19199                                                      if (((word >> 11) & 0x1) == 0)
19200                                                        {
19201                                                          if (((word >> 12) & 0x1) == 0)
19202                                                            {
19203                                                              /* 33222222222211111111110000000000
19204                                                                 10987654321098765432109876543210
19205                                                                 010001x10x1xxxxx010001xxxxxxxxxx
19206                                                                 sqxtnt.  */
19207                                                              return 2278;
19208                                                            }
19209                                                          else
19210                                                            {
19211                                                              /* 33222222222211111111110000000000
19212                                                                 10987654321098765432109876543210
19213                                                                 010001x10x1xxxxx010101xxxxxxxxxx
19214                                                                 sqxtunt.  */
19215                                                              return 2280;
19216                                                            }
19217                                                        }
19218                                                      else
19219                                                        {
19220                                                          /* 33222222222211111111110000000000
19221                                                             10987654321098765432109876543210
19222                                                             010001x10x1xxxxx010x11xxxxxxxxxx
19223                                                             uqxtnt.  */
19224                                                          return 2355;
19225                                                        }
19226                                                    }
19227                                                }
19228                                              else
19229                                                {
19230                                                  /* 33222222222211111111110000000000
19231                                                     10987654321098765432109876543210
19232                                                     110001x10x1xxxxx010xxxxxxxxxxxxx
19233                                                     ld1w.  */
19234                                                  return 1647;
19235                                                }
19236                                            }
19237                                          else
19238                                            {
19239                                              /* 33222222222211111111110000000000
19240                                                 10987654321098765432109876543210
19241                                                 x10001x11x1xxxxx010xxxxxxxxxxxxx
19242                                                 ld1d.  */
19243                                              return 1569;
19244                                            }
19245                                        }
19246                                    }
19247                                  else
19248                                    {
19249                                      if (((word >> 21) & 0x1) == 0)
19250                                        {
19251                                          if (((word >> 31) & 0x1) == 0)
19252                                            {
19253                                              if (((word >> 11) & 0x1) == 0)
19254                                                {
19255                                                  if (((word >> 10) & 0x1) == 0)
19256                                                    {
19257                                                      if (((word >> 12) & 0x1) == 0)
19258                                                        {
19259                                                          /* 33222222222211111111110000000000
19260                                                             10987654321098765432109876543210
19261                                                             010001x1xx0xxxxx110000xxxxxxxxxx
19262                                                             sabalb.  */
19263                                                          return 2178;
19264                                                        }
19265                                                      else
19266                                                        {
19267                                                          if (((word >> 23) & 0x1) == 0)
19268                                                            {
19269                                                              /* 33222222222211111111110000000000
19270                                                                 10987654321098765432109876543210
19271                                                                 010001x10x0xxxxx110100xxxxxxxxxx
19272                                                                 adclb.  */
19273                                                              return 2103;
19274                                                            }
19275                                                          else
19276                                                            {
19277                                                              /* 33222222222211111111110000000000
19278                                                                 10987654321098765432109876543210
19279                                                                 010001x11x0xxxxx110100xxxxxxxxxx
19280                                                                 sbclb.  */
19281                                                              return 2188;
19282                                                            }
19283                                                        }
19284                                                    }
19285                                                  else
19286                                                    {
19287                                                      if (((word >> 12) & 0x1) == 0)
19288                                                        {
19289                                                          /* 33222222222211111111110000000000
19290                                                             10987654321098765432109876543210
19291                                                             010001x1xx0xxxxx110001xxxxxxxxxx
19292                                                             sabalt.  */
19293                                                          return 2179;
19294                                                        }
19295                                                      else
19296                                                        {
19297                                                          if (((word >> 23) & 0x1) == 0)
19298                                                            {
19299                                                              /* 33222222222211111111110000000000
19300                                                                 10987654321098765432109876543210
19301                                                                 010001x10x0xxxxx110101xxxxxxxxxx
19302                                                                 adclt.  */
19303                                                              return 2104;
19304                                                            }
19305                                                          else
19306                                                            {
19307                                                              /* 33222222222211111111110000000000
19308                                                                 10987654321098765432109876543210
19309                                                                 010001x11x0xxxxx110101xxxxxxxxxx
19310                                                                 sbclt.  */
19311                                                              return 2189;
19312                                                            }
19313                                                        }
19314                                                    }
19315                                                }
19316                                              else
19317                                                {
19318                                                  if (((word >> 12) & 0x1) == 0)
19319                                                    {
19320                                                      if (((word >> 10) & 0x1) == 0)
19321                                                        {
19322                                                          /* 33222222222211111111110000000000
19323                                                             10987654321098765432109876543210
19324                                                             010001x1xx0xxxxx110010xxxxxxxxxx
19325                                                             uabalb.  */
19326                                                          return 2309;
19327                                                        }
19328                                                      else
19329                                                        {
19330                                                          /* 33222222222211111111110000000000
19331                                                             10987654321098765432109876543210
19332                                                             010001x1xx0xxxxx110011xxxxxxxxxx
19333                                                             uabalt.  */
19334                                                          return 2310;
19335                                                        }
19336                                                    }
19337                                                  else
19338                                                    {
19339                                                      if (((word >> 16) & 0x1) == 0)
19340                                                        {
19341                                                          /* 33222222222211111111110000000000
19342                                                             10987654321098765432109876543210
19343                                                             010001x1xx0xxxx011011xxxxxxxxxxx
19344                                                             cadd.  */
19345                                                          return 2112;
19346                                                        }
19347                                                      else
19348                                                        {
19349                                                          /* 33222222222211111111110000000000
19350                                                             10987654321098765432109876543210
19351                                                             010001x1xx0xxxx111011xxxxxxxxxxx
19352                                                             sqcadd.  */
19353                                                          return 2220;
19354                                                        }
19355                                                    }
19356                                                }
19357                                            }
19358                                          else
19359                                            {
19360                                              if (((word >> 22) & 0x1) == 0)
19361                                                {
19362                                                  if (((word >> 23) & 0x1) == 0)
19363                                                    {
19364                                                      /* 33222222222211111111110000000000
19365                                                         10987654321098765432109876543210
19366                                                         110001x1000xxxxx110xxxxxxxxxxxxx
19367                                                         ldnt1w.  */
19368                                                      return 2154;
19369                                                    }
19370                                                  else
19371                                                    {
19372                                                      /* 33222222222211111111110000000000
19373                                                         10987654321098765432109876543210
19374                                                         110001x1100xxxxx110xxxxxxxxxxxxx
19375                                                         ldnt1d.  */
19376                                                      return 2147;
19377                                                    }
19378                                                }
19379                                              else
19380                                                {
19381                                                  if (((word >> 23) & 0x1) == 0)
19382                                                    {
19383                                                      /* 33222222222211111111110000000000
19384                                                         10987654321098765432109876543210
19385                                                         110001x1010xxxxx110xxxxxxxxxxxxx
19386                                                         ld1w.  */
19387                                                      return 1648;
19388                                                    }
19389                                                  else
19390                                                    {
19391                                                      /* 33222222222211111111110000000000
19392                                                         10987654321098765432109876543210
19393                                                         110001x1110xxxxx110xxxxxxxxxxxxx
19394                                                         ld1d.  */
19395                                                      return 1570;
19396                                                    }
19397                                                }
19398                                            }
19399                                        }
19400                                      else
19401                                        {
19402                                          if (((word >> 23) & 0x1) == 0)
19403                                            {
19404                                              if (((word >> 22) & 0x1) == 0)
19405                                                {
19406                                                  /* 33222222222211111111110000000000
19407                                                     10987654321098765432109876543210
19408                                                     x10001x1001xxxxx110xxxxxxxxxxxxx
19409                                                     ld1w.  */
19410                                                  return 1653;
19411                                                }
19412                                              else
19413                                                {
19414                                                  /* 33222222222211111111110000000000
19415                                                     10987654321098765432109876543210
19416                                                     x10001x1011xxxxx110xxxxxxxxxxxxx
19417                                                     ld1w.  */
19418                                                  return 1649;
19419                                                }
19420                                            }
19421                                          else
19422                                            {
19423                                              if (((word >> 31) & 0x1) == 0)
19424                                                {
19425                                                  /* 33222222222211111111110000000000
19426                                                     10987654321098765432109876543210
19427                                                     010001x11x1xxxxx110xxxxxxxxxxxxx
19428                                                     histcnt.  */
19429                                                  return 2143;
19430                                                }
19431                                              else
19432                                                {
19433                                                  if (((word >> 22) & 0x1) == 0)
19434                                                    {
19435                                                      /* 33222222222211111111110000000000
19436                                                         10987654321098765432109876543210
19437                                                         110001x1101xxxxx110xxxxxxxxxxxxx
19438                                                         ld1d.  */
19439                                                      return 1573;
19440                                                    }
19441                                                  else
19442                                                    {
19443                                                      /* 33222222222211111111110000000000
19444                                                         10987654321098765432109876543210
19445                                                         110001x1111xxxxx110xxxxxxxxxxxxx
19446                                                         ld1d.  */
19447                                                      return 1571;
19448                                                    }
19449                                                }
19450                                            }
19451                                        }
19452                                    }
19453                                }
19454                            }
19455                          else
19456                            {
19457                              if (((word >> 14) & 0x1) == 0)
19458                                {
19459                                  if (((word >> 15) & 0x1) == 0)
19460                                    {
19461                                      if (((word >> 21) & 0x1) == 0)
19462                                        {
19463                                          if (((word >> 31) & 0x1) == 0)
19464                                            {
19465                                              if (((word >> 10) & 0x1) == 0)
19466                                                {
19467                                                  if (((word >> 11) & 0x1) == 0)
19468                                                    {
19469                                                      /* 33222222222211111111110000000000
19470                                                         10987654321098765432109876543210
19471                                                         010001x1xx0xxxxx001x00xxxxxxxxxx
19472                                                         sabdlb.  */
19473                                                      return 2180;
19474                                                    }
19475                                                  else
19476                                                    {
19477                                                      /* 33222222222211111111110000000000
19478                                                         10987654321098765432109876543210
19479                                                         010001x1xx0xxxxx001x10xxxxxxxxxx
19480                                                         uabdlb.  */
19481                                                      return 2311;
19482                                                    }
19483                                                }
19484                                              else
19485                                                {
19486                                                  if (((word >> 11) & 0x1) == 0)
19487                                                    {
19488                                                      /* 33222222222211111111110000000000
19489                                                         10987654321098765432109876543210
19490                                                         010001x1xx0xxxxx001x01xxxxxxxxxx
19491                                                         sabdlt.  */
19492                                                      return 2181;
19493                                                    }
19494                                                  else
19495                                                    {
19496                                                      /* 33222222222211111111110000000000
19497                                                         10987654321098765432109876543210
19498                                                         010001x1xx0xxxxx001x11xxxxxxxxxx
19499                                                         uabdlt.  */
19500                                                      return 2312;
19501                                                    }
19502                                                }
19503                                            }
19504                                          else
19505                                            {
19506                                              /* 33222222222211111111110000000000
19507                                                 10987654321098765432109876543210
19508                                                 110001x1xx0xxxxx001xxxxxxxxxxxxx
19509                                                 ldff1sw.  */
19510                                              return 1737;
19511                                            }
19512                                        }
19513                                      else
19514                                        {
19515                                          if (((word >> 23) & 0x1) == 0)
19516                                            {
19517                                              if (((word >> 31) & 0x1) == 0)
19518                                                {
19519                                                  if (((word >> 10) & 0x1) == 0)
19520                                                    {
19521                                                      if (((word >> 11) & 0x1) == 0)
19522                                                        {
19523                                                          if (((word >> 12) & 0x1) == 0)
19524                                                            {
19525                                                              /* 33222222222211111111110000000000
19526                                                                 10987654321098765432109876543210
19527                                                                 010001x10x1xxxxx001000xxxxxxxxxx
19528                                                                 sqshrnb.  */
19529                                                              return 2271;
19530                                                            }
19531                                                          else
19532                                                            {
19533                                                              /* 33222222222211111111110000000000
19534                                                                 10987654321098765432109876543210
19535                                                                 010001x10x1xxxxx001100xxxxxxxxxx
19536                                                                 uqshrnb.  */
19537                                                              return 2350;
19538                                                            }
19539                                                        }
19540                                                      else
19541                                                        {
19542                                                          if (((word >> 12) & 0x1) == 0)
19543                                                            {
19544                                                              /* 33222222222211111111110000000000
19545                                                                 10987654321098765432109876543210
19546                                                                 010001x10x1xxxxx001010xxxxxxxxxx
19547                                                                 sqrshrnb.  */
19548                                                              return 2263;
19549                                                            }
19550                                                          else
19551                                                            {
19552                                                              /* 33222222222211111111110000000000
19553                                                                 10987654321098765432109876543210
19554                                                                 010001x10x1xxxxx001110xxxxxxxxxx
19555                                                                 uqrshrnb.  */
19556                                                              return 2345;
19557                                                            }
19558                                                        }
19559                                                    }
19560                                                  else
19561                                                    {
19562                                                      if (((word >> 11) & 0x1) == 0)
19563                                                        {
19564                                                          if (((word >> 12) & 0x1) == 0)
19565                                                            {
19566                                                              /* 33222222222211111111110000000000
19567                                                                 10987654321098765432109876543210
19568                                                                 010001x10x1xxxxx001001xxxxxxxxxx
19569                                                                 sqshrnt.  */
19570                                                              return 2272;
19571                                                            }
19572                                                          else
19573                                                            {
19574                                                              /* 33222222222211111111110000000000
19575                                                                 10987654321098765432109876543210
19576                                                                 010001x10x1xxxxx001101xxxxxxxxxx
19577                                                                 uqshrnt.  */
19578                                                              return 2351;
19579                                                            }
19580                                                        }
19581                                                      else
19582                                                        {
19583                                                          if (((word >> 12) & 0x1) == 0)
19584                                                            {
19585                                                              /* 33222222222211111111110000000000
19586                                                                 10987654321098765432109876543210
19587                                                                 010001x10x1xxxxx001011xxxxxxxxxx
19588                                                                 sqrshrnt.  */
19589                                                              return 2264;
19590                                                            }
19591                                                          else
19592                                                            {
19593                                                              /* 33222222222211111111110000000000
19594                                                                 10987654321098765432109876543210
19595                                                                 010001x10x1xxxxx001111xxxxxxxxxx
19596                                                                 uqrshrnt.  */
19597                                                              return 2346;
19598                                                            }
19599                                                        }
19600                                                    }
19601                                                }
19602                                              else
19603                                                {
19604                                                  /* 33222222222211111111110000000000
19605                                                     10987654321098765432109876543210
19606                                                     110001x10x1xxxxx001xxxxxxxxxxxxx
19607                                                     ldff1sw.  */
19608                                                  return 1738;
19609                                                }
19610                                            }
19611                                          else
19612                                            {
19613                                              if (((word >> 12) & 0x1) == 0)
19614                                                {
19615                                                  /* 33222222222211111111110000000000
19616                                                     10987654321098765432109876543210
19617                                                     x10001x11x1xxxxx0010xxxxxxxxxxxx
19618                                                     sqrshrn.  */
19619                                                  return 2469;
19620                                                }
19621                                              else
19622                                                {
19623                                                  /* 33222222222211111111110000000000
19624                                                     10987654321098765432109876543210
19625                                                     x10001x11x1xxxxx0011xxxxxxxxxxxx
19626                                                     uqrshrn.  */
19627                                                  return 2474;
19628                                                }
19629                                            }
19630                                        }
19631                                    }
19632                                  else
19633                                    {
19634                                      if (((word >> 21) & 0x1) == 0)
19635                                        {
19636                                          if (((word >> 31) & 0x1) == 0)
19637                                            {
19638                                              if (((word >> 10) & 0x1) == 0)
19639                                                {
19640                                                  if (((word >> 11) & 0x1) == 0)
19641                                                    {
19642                                                      if (((word >> 12) & 0x1) == 0)
19643                                                        {
19644                                                          /* 33222222222211111111110000000000
19645                                                             10987654321098765432109876543210
19646                                                             010001x1xx0xxxxx101000xxxxxxxxxx
19647                                                             sshllb.  */
19648                                                          return 2287;
19649                                                        }
19650                                                      else
19651                                                        {
19652                                                          /* 33222222222211111111110000000000
19653                                                             10987654321098765432109876543210
19654                                                             010001x1xx0xxxxx101100xxxxxxxxxx
19655                                                             bext.  */
19656                                                          return 2392;
19657                                                        }
19658                                                    }
19659                                                  else
19660                                                    {
19661                                                      if (((word >> 12) & 0x1) == 0)
19662                                                        {
19663                                                          /* 33222222222211111111110000000000
19664                                                             10987654321098765432109876543210
19665                                                             010001x1xx0xxxxx101010xxxxxxxxxx
19666                                                             ushllb.  */
19667                                                          return 2363;
19668                                                        }
19669                                                      else
19670                                                        {
19671                                                          /* 33222222222211111111110000000000
19672                                                             10987654321098765432109876543210
19673                                                             010001x1xx0xxxxx101110xxxxxxxxxx
19674                                                             bgrp.  */
19675                                                          return 2393;
19676                                                        }
19677                                                    }
19678                                                }
19679                                              else
19680                                                {
19681                                                  if (((word >> 11) & 0x1) == 0)
19682                                                    {
19683                                                      if (((word >> 12) & 0x1) == 0)
19684                                                        {
19685                                                          /* 33222222222211111111110000000000
19686                                                             10987654321098765432109876543210
19687                                                             010001x1xx0xxxxx101001xxxxxxxxxx
19688                                                             sshllt.  */
19689                                                          return 2288;
19690                                                        }
19691                                                      else
19692                                                        {
19693                                                          /* 33222222222211111111110000000000
19694                                                             10987654321098765432109876543210
19695                                                             010001x1xx0xxxxx101101xxxxxxxxxx
19696                                                             bdep.  */
19697                                                          return 2391;
19698                                                        }
19699                                                    }
19700                                                  else
19701                                                    {
19702                                                      /* 33222222222211111111110000000000
19703                                                         10987654321098765432109876543210
19704                                                         010001x1xx0xxxxx101x11xxxxxxxxxx
19705                                                         ushllt.  */
19706                                                      return 2364;
19707                                                    }
19708                                                }
19709                                            }
19710                                          else
19711                                            {
19712                                              /* 33222222222211111111110000000000
19713                                                 10987654321098765432109876543210
19714                                                 110001x1xx0xxxxx101xxxxxxxxxxxxx
19715                                                 ldff1sw.  */
19716                                              return 1739;
19717                                            }
19718                                        }
19719                                      else
19720                                        {
19721                                          if (((word >> 22) & 0x1) == 0)
19722                                            {
19723                                              if (((word >> 31) & 0x1) == 0)
19724                                                {
19725                                                  /* 33222222222211111111110000000000
19726                                                     10987654321098765432109876543210
19727                                                     010001x1x01xxxxx101xxxxxxxxxxxxx
19728                                                     histseg.  */
19729                                                  return 2144;
19730                                                }
19731                                              else
19732                                                {
19733                                                  /* 33222222222211111111110000000000
19734                                                     10987654321098765432109876543210
19735                                                     110001x1x01xxxxx101xxxxxxxxxxxxx
19736                                                     ldff1sw.  */
19737                                                  return 1741;
19738                                                }
19739                                            }
19740                                          else
19741                                            {
19742                                              /* 33222222222211111111110000000000
19743                                                 10987654321098765432109876543210
19744                                                 x10001x1x11xxxxx101xxxxxxxxxxxxx
19745                                                 ldff1sw.  */
19746                                              return 1740;
19747                                            }
19748                                        }
19749                                    }
19750                                }
19751                              else
19752                                {
19753                                  if (((word >> 15) & 0x1) == 0)
19754                                    {
19755                                      if (((word >> 21) & 0x1) == 0)
19756                                        {
19757                                          if (((word >> 31) & 0x1) == 0)
19758                                            {
19759                                              if (((word >> 10) & 0x1) == 0)
19760                                                {
19761                                                  if (((word >> 11) & 0x1) == 0)
19762                                                    {
19763                                                      if (((word >> 12) & 0x1) == 0)
19764                                                        {
19765                                                          /* 33222222222211111111110000000000
19766                                                             10987654321098765432109876543210
19767                                                             010001x1xx0xxxxx011000xxxxxxxxxx
19768                                                             sqdmullb.  */
19769                                                          return 2241;
19770                                                        }
19771                                                      else
19772                                                        {
19773                                                          /* 33222222222211111111110000000000
19774                                                             10987654321098765432109876543210
19775                                                             010001x1xx0xxxxx011100xxxxxxxxxx
19776                                                             smullb.  */
19777                                                          return 2213;
19778                                                        }
19779                                                    }
19780                                                  else
19781                                                    {
19782                                                      if (((word >> 12) & 0x1) == 0)
19783                                                        {
19784                                                          if (((word >> 22) & 0x1) == 0)
19785                                                            {
19786                                                              /* 33222222222211111111110000000000
19787                                                                 10987654321098765432109876543210
19788                                                                 010001x1x00xxxxx011010xxxxxxxxxx
19789                                                                 pmullb.  */
19790                                                              return 2388;
19791                                                            }
19792                                                          else
19793                                                            {
19794                                                              /* 33222222222211111111110000000000
19795                                                                 10987654321098765432109876543210
19796                                                                 010001x1x10xxxxx011010xxxxxxxxxx
19797                                                                 pmullb.  */
19798                                                              return 2169;
19799                                                            }
19800                                                        }
19801                                                      else
19802                                                        {
19803                                                          /* 33222222222211111111110000000000
19804                                                             10987654321098765432109876543210
19805                                                             010001x1xx0xxxxx011110xxxxxxxxxx
19806                                                             umullb.  */
19807                                                          return 2338;
19808                                                        }
19809                                                    }
19810                                                }
19811                                              else
19812                                                {
19813                                                  if (((word >> 11) & 0x1) == 0)
19814                                                    {
19815                                                      if (((word >> 12) & 0x1) == 0)
19816                                                        {
19817                                                          /* 33222222222211111111110000000000
19818                                                             10987654321098765432109876543210
19819                                                             010001x1xx0xxxxx011001xxxxxxxxxx
19820                                                             sqdmullt.  */
19821                                                          return 2244;
19822                                                        }
19823                                                      else
19824                                                        {
19825                                                          /* 33222222222211111111110000000000
19826                                                             10987654321098765432109876543210
19827                                                             010001x1xx0xxxxx011101xxxxxxxxxx
19828                                                             smullt.  */
19829                                                          return 2216;
19830                                                        }
19831                                                    }
19832                                                  else
19833                                                    {
19834                                                      if (((word >> 12) & 0x1) == 0)
19835                                                        {
19836                                                          if (((word >> 22) & 0x1) == 0)
19837                                                            {
19838                                                              /* 33222222222211111111110000000000
19839                                                                 10987654321098765432109876543210
19840                                                                 010001x1x00xxxxx011011xxxxxxxxxx
19841                                                                 pmullt.  */
19842                                                              return 2389;
19843                                                            }
19844                                                          else
19845                                                            {
19846                                                              /* 33222222222211111111110000000000
19847                                                                 10987654321098765432109876543210
19848                                                                 010001x1x10xxxxx011011xxxxxxxxxx
19849                                                                 pmullt.  */
19850                                                              return 2170;
19851                                                            }
19852                                                        }
19853                                                      else
19854                                                        {
19855                                                          /* 33222222222211111111110000000000
19856                                                             10987654321098765432109876543210
19857                                                             010001x1xx0xxxxx011111xxxxxxxxxx
19858                                                             umullt.  */
19859                                                          return 2341;
19860                                                        }
19861                                                    }
19862                                                }
19863                                            }
19864                                          else
19865                                            {
19866                                              if (((word >> 23) & 0x1) == 0)
19867                                                {
19868                                                  /* 33222222222211111111110000000000
19869                                                     10987654321098765432109876543210
19870                                                     110001x10x0xxxxx011xxxxxxxxxxxxx
19871                                                     ldff1w.  */
19872                                                  return 1748;
19873                                                }
19874                                              else
19875                                                {
19876                                                  /* 33222222222211111111110000000000
19877                                                     10987654321098765432109876543210
19878                                                     110001x11x0xxxxx011xxxxxxxxxxxxx
19879                                                     ldff1d.  */
19880                                                  return 1693;
19881                                                }
19882                                            }
19883                                        }
19884                                      else
19885                                        {
19886                                          if (((word >> 31) & 0x1) == 0)
19887                                            {
19888                                              if (((word >> 10) & 0x1) == 0)
19889                                                {
19890                                                  if (((word >> 11) & 0x1) == 0)
19891                                                    {
19892                                                      if (((word >> 12) & 0x1) == 0)
19893                                                        {
19894                                                          /* 33222222222211111111110000000000
19895                                                             10987654321098765432109876543210
19896                                                             010001x1xx1xxxxx011000xxxxxxxxxx
19897                                                             addhnb.  */
19898                                                          return 2105;
19899                                                        }
19900                                                      else
19901                                                        {
19902                                                          /* 33222222222211111111110000000000
19903                                                             10987654321098765432109876543210
19904                                                             010001x1xx1xxxxx011100xxxxxxxxxx
19905                                                             subhnb.  */
19906                                                          return 2303;
19907                                                        }
19908                                                    }
19909                                                  else
19910                                                    {
19911                                                      if (((word >> 12) & 0x1) == 0)
19912                                                        {
19913                                                          /* 33222222222211111111110000000000
19914                                                             10987654321098765432109876543210
19915                                                             010001x1xx1xxxxx011010xxxxxxxxxx
19916                                                             raddhnb.  */
19917                                                          return 2171;
19918                                                        }
19919                                                      else
19920                                                        {
19921                                                          /* 33222222222211111111110000000000
19922                                                             10987654321098765432109876543210
19923                                                             010001x1xx1xxxxx011110xxxxxxxxxx
19924                                                             rsubhnb.  */
19925                                                          return 2175;
19926                                                        }
19927                                                    }
19928                                                }
19929                                              else
19930                                                {
19931                                                  if (((word >> 11) & 0x1) == 0)
19932                                                    {
19933                                                      if (((word >> 12) & 0x1) == 0)
19934                                                        {
19935                                                          /* 33222222222211111111110000000000
19936                                                             10987654321098765432109876543210
19937                                                             010001x1xx1xxxxx011001xxxxxxxxxx
19938                                                             addhnt.  */
19939                                                          return 2106;
19940                                                        }
19941                                                      else
19942                                                        {
19943                                                          /* 33222222222211111111110000000000
19944                                                             10987654321098765432109876543210
19945                                                             010001x1xx1xxxxx011101xxxxxxxxxx
19946                                                             subhnt.  */
19947                                                          return 2304;
19948                                                        }
19949                                                    }
19950                                                  else
19951                                                    {
19952                                                      if (((word >> 12) & 0x1) == 0)
19953                                                        {
19954                                                          /* 33222222222211111111110000000000
19955                                                             10987654321098765432109876543210
19956                                                             010001x1xx1xxxxx011011xxxxxxxxxx
19957                                                             raddhnt.  */
19958                                                          return 2172;
19959                                                        }
19960                                                      else
19961                                                        {
19962                                                          /* 33222222222211111111110000000000
19963                                                             10987654321098765432109876543210
19964                                                             010001x1xx1xxxxx011111xxxxxxxxxx
19965                                                             rsubhnt.  */
19966                                                          return 2176;
19967                                                        }
19968                                                    }
19969                                                }
19970                                            }
19971                                          else
19972                                            {
19973                                              if (((word >> 23) & 0x1) == 0)
19974                                                {
19975                                                  /* 33222222222211111111110000000000
19976                                                     10987654321098765432109876543210
19977                                                     110001x10x1xxxxx011xxxxxxxxxxxxx
19978                                                     ldff1w.  */
19979                                                  return 1749;
19980                                                }
19981                                              else
19982                                                {
19983                                                  /* 33222222222211111111110000000000
19984                                                     10987654321098765432109876543210
19985                                                     110001x11x1xxxxx011xxxxxxxxxxxxx
19986                                                     ldff1d.  */
19987                                                  return 1694;
19988                                                }
19989                                            }
19990                                        }
19991                                    }
19992                                  else
19993                                    {
19994                                      if (((word >> 21) & 0x1) == 0)
19995                                        {
19996                                          if (((word >> 31) & 0x1) == 0)
19997                                            {
19998                                              if (((word >> 10) & 0x1) == 0)
19999                                                {
20000                                                  if (((word >> 11) & 0x1) == 0)
20001                                                    {
20002                                                      if (((word >> 12) & 0x1) == 0)
20003                                                        {
20004                                                          /* 33222222222211111111110000000000
20005                                                             10987654321098765432109876543210
20006                                                             010001x1xx0xxxxx111000xxxxxxxxxx
20007                                                             ssra.  */
20008                                                          return 2289;
20009                                                        }
20010                                                      else
20011                                                        {
20012                                                          /* 33222222222211111111110000000000
20013                                                             10987654321098765432109876543210
20014                                                             010001x1xx0xxxxx111100xxxxxxxxxx
20015                                                             sri.  */
20016                                                          return 2282;
20017                                                        }
20018                                                    }
20019                                                  else
20020                                                    {
20021                                                      if (((word >> 12) & 0x1) == 0)
20022                                                        {
20023                                                          /* 33222222222211111111110000000000
20024                                                             10987654321098765432109876543210
20025                                                             010001x1xx0xxxxx111010xxxxxxxxxx
20026                                                             srsra.  */
20027                                                          return 2286;
20028                                                        }
20029                                                      else
20030                                                        {
20031                                                          /* 33222222222211111111110000000000
20032                                                             10987654321098765432109876543210
20033                                                             010001x1xx0xxxxx111110xxxxxxxxxx
20034                                                             saba.  */
20035                                                          return 2177;
20036                                                        }
20037                                                    }
20038                                                }
20039                                              else
20040                                                {
20041                                                  if (((word >> 11) & 0x1) == 0)
20042                                                    {
20043                                                      if (((word >> 12) & 0x1) == 0)
20044                                                        {
20045                                                          /* 33222222222211111111110000000000
20046                                                             10987654321098765432109876543210
20047                                                             010001x1xx0xxxxx111001xxxxxxxxxx
20048                                                             usra.  */
20049                                                          return 2366;
20050                                                        }
20051                                                      else
20052                                                        {
20053                                                          /* 33222222222211111111110000000000
20054                                                             10987654321098765432109876543210
20055                                                             010001x1xx0xxxxx111101xxxxxxxxxx
20056                                                             sli.  */
20057                                                          return 2195;
20058                                                        }
20059                                                    }
20060                                                  else
20061                                                    {
20062                                                      if (((word >> 12) & 0x1) == 0)
20063                                                        {
20064                                                          /* 33222222222211111111110000000000
20065                                                             10987654321098765432109876543210
20066                                                             010001x1xx0xxxxx111011xxxxxxxxxx
20067                                                             ursra.  */
20068                                                          return 2362;
20069                                                        }
20070                                                      else
20071                                                        {
20072                                                          /* 33222222222211111111110000000000
20073                                                             10987654321098765432109876543210
20074                                                             010001x1xx0xxxxx111111xxxxxxxxxx
20075                                                             uaba.  */
20076                                                          return 2308;
20077                                                        }
20078                                                    }
20079                                                }
20080                                            }
20081                                          else
20082                                            {
20083                                              if (((word >> 22) & 0x1) == 0)
20084                                                {
20085                                                  if (((word >> 23) & 0x1) == 0)
20086                                                    {
20087                                                      /* 33222222222211111111110000000000
20088                                                         10987654321098765432109876543210
20089                                                         110001x1000xxxxx111xxxxxxxxxxxxx
20090                                                         prfw.  */
20091                                                      return 1846;
20092                                                    }
20093                                                  else
20094                                                    {
20095                                                      /* 33222222222211111111110000000000
20096                                                         10987654321098765432109876543210
20097                                                         110001x1100xxxxx111xxxxxxxxxxxxx
20098                                                         prfd.  */
20099                                                      return 1832;
20100                                                    }
20101                                                }
20102                                              else
20103                                                {
20104                                                  if (((word >> 23) & 0x1) == 0)
20105                                                    {
20106                                                      /* 33222222222211111111110000000000
20107                                                         10987654321098765432109876543210
20108                                                         110001x1010xxxxx111xxxxxxxxxxxxx
20109                                                         ldff1w.  */
20110                                                      return 1750;
20111                                                    }
20112                                                  else
20113                                                    {
20114                                                      /* 33222222222211111111110000000000
20115                                                         10987654321098765432109876543210
20116                                                         110001x1110xxxxx111xxxxxxxxxxxxx
20117                                                         ldff1d.  */
20118                                                      return 1695;
20119                                                    }
20120                                                }
20121                                            }
20122                                        }
20123                                      else
20124                                        {
20125                                          if (((word >> 22) & 0x1) == 0)
20126                                            {
20127                                              if (((word >> 23) & 0x1) == 0)
20128                                                {
20129                                                  if (((word >> 31) & 0x1) == 0)
20130                                                    {
20131                                                      if (((word >> 10) & 0x1) == 0)
20132                                                        {
20133                                                          if (((word >> 12) & 0x1) == 0)
20134                                                            {
20135                                                              if (((word >> 16) & 0x1) == 0)
20136                                                                {
20137                                                                  if (((word >> 17) & 0x1) == 0)
20138                                                                    {
20139                                                                      /* 33222222222211111111110000000000
20140                                                                         10987654321098765432109876543210
20141                                                                         010001x1001xxx001110x0xxxxxxxxxx
20142                                                                         aesmc.  */
20143                                                                      return 2387;
20144                                                                    }
20145                                                                  else
20146                                                                    {
20147                                                                      /* 33222222222211111111110000000000
20148                                                                         10987654321098765432109876543210
20149                                                                         010001x1001xxx101110x0xxxxxxxxxx
20150                                                                         aese.  */
20151                                                                      return 2385;
20152                                                                    }
20153                                                                }
20154                                                              else
20155                                                                {
20156                                                                  /* 33222222222211111111110000000000
20157                                                                     10987654321098765432109876543210
20158                                                                     010001x1001xxxx11110x0xxxxxxxxxx
20159                                                                     sm4e.  */
20160                                                                  return 2382;
20161                                                                }
20162                                                            }
20163                                                          else
20164                                                            {
20165                                                              /* 33222222222211111111110000000000
20166                                                                 10987654321098765432109876543210
20167                                                                 010001x1001xxxxx1111x0xxxxxxxxxx
20168                                                                 sm4ekey.  */
20169                                                              return 2383;
20170                                                            }
20171                                                        }
20172                                                      else
20173                                                        {
20174                                                          if (((word >> 12) & 0x1) == 0)
20175                                                            {
20176                                                              if (((word >> 17) & 0x1) == 0)
20177                                                                {
20178                                                                  /* 33222222222211111111110000000000
20179                                                                     10987654321098765432109876543210
20180                                                                     010001x1001xxx0x1110x1xxxxxxxxxx
20181                                                                     aesimc.  */
20182                                                                  return 2386;
20183                                                                }
20184                                                              else
20185                                                                {
20186                                                                  /* 33222222222211111111110000000000
20187                                                                     10987654321098765432109876543210
20188                                                                     010001x1001xxx1x1110x1xxxxxxxxxx
20189                                                                     aesd.  */
20190                                                                  return 2384;
20191                                                                }
20192                                                            }
20193                                                          else
20194                                                            {
20195                                                              /* 33222222222211111111110000000000
20196                                                                 10987654321098765432109876543210
20197                                                                 010001x1001xxxxx1111x1xxxxxxxxxx
20198                                                                 rax1.  */
20199                                                              return 2390;
20200                                                            }
20201                                                        }
20202                                                    }
20203                                                  else
20204                                                    {
20205                                                      /* 33222222222211111111110000000000
20206                                                         10987654321098765432109876543210
20207                                                         110001x1001xxxxx111xxxxxxxxxxxxx
20208                                                         ldff1w.  */
20209                                                      return 1753;
20210                                                    }
20211                                                }
20212                                              else
20213                                                {
20214                                                  /* 33222222222211111111110000000000
20215                                                     10987654321098765432109876543210
20216                                                     x10001x1101xxxxx111xxxxxxxxxxxxx
20217                                                     ldff1d.  */
20218                                                  return 1697;
20219                                                }
20220                                            }
20221                                          else
20222                                            {
20223                                              if (((word >> 23) & 0x1) == 0)
20224                                                {
20225                                                  /* 33222222222211111111110000000000
20226                                                     10987654321098765432109876543210
20227                                                     x10001x1011xxxxx111xxxxxxxxxxxxx
20228                                                     ldff1w.  */
20229                                                  return 1751;
20230                                                }
20231                                              else
20232                                                {
20233                                                  /* 33222222222211111111110000000000
20234                                                     10987654321098765432109876543210
20235                                                     x10001x1111xxxxx111xxxxxxxxxxxxx
20236                                                     ldff1d.  */
20237                                                  return 1696;
20238                                                }
20239                                            }
20240                                        }
20241                                    }
20242                                }
20243                            }
20244                        }
20245                    }
20246                  else
20247                    {
20248                      if (((word >> 15) & 0x1) == 0)
20249                        {
20250                          if (((word >> 14) & 0x1) == 0)
20251                            {
20252                              if (((word >> 13) & 0x1) == 0)
20253                                {
20254                                  if (((word >> 30) & 0x1) == 0)
20255                                    {
20256                                      if (((word >> 21) & 0x1) == 0)
20257                                        {
20258                                          if (((word >> 31) & 0x1) == 0)
20259                                            {
20260                                              if (((word >> 4) & 0x1) == 0)
20261                                                {
20262                                                  /* 33222222222211111111110000000000
20263                                                     10987654321098765432109876543210
20264                                                     001001x1xx0xxxxx000xxxxxxxx0xxxx
20265                                                     cmpge.  */
20266                                                  return 1376;
20267                                                }
20268                                              else
20269                                                {
20270                                                  /* 33222222222211111111110000000000
20271                                                     10987654321098765432109876543210
20272                                                     001001x1xx0xxxxx000xxxxxxxx1xxxx
20273                                                     cmpgt.  */
20274                                                  return 1379;
20275                                                }
20276                                            }
20277                                          else
20278                                            {
20279                                              if (((word >> 23) & 0x1) == 0)
20280                                                {
20281                                                  /* 33222222222211111111110000000000
20282                                                     10987654321098765432109876543210
20283                                                     101001x10x0xxxxx000xxxxxxxxxxxxx
20284                                                     ld1rqw.  */
20285                                                  return 1603;
20286                                                }
20287                                              else
20288                                                {
20289                                                  /* 33222222222211111111110000000000
20290                                                     10987654321098765432109876543210
20291                                                     101001x11x0xxxxx000xxxxxxxxxxxxx
20292                                                     ld1rqd.  */
20293                                                  return 1599;
20294                                                }
20295                                            }
20296                                        }
20297                                      else
20298                                        {
20299                                          if (((word >> 31) & 0x1) == 0)
20300                                            {
20301                                              if (((word >> 4) & 0x1) == 0)
20302                                                {
20303                                                  if (((word >> 10) & 0x1) == 0)
20304                                                    {
20305                                                      if (((word >> 11) & 0x1) == 0)
20306                                                        {
20307                                                          if (((word >> 12) & 0x1) == 0)
20308                                                            {
20309                                                              /* 33222222222211111111110000000000
20310                                                                 10987654321098765432109876543210
20311                                                                 001001x1xx1xxxxx000000xxxxx0xxxx
20312                                                                 whilege.  */
20313                                                              return 2371;
20314                                                            }
20315                                                          else
20316                                                            {
20317                                                              /* 33222222222211111111110000000000
20318                                                                 10987654321098765432109876543210
20319                                                                 001001x1xx1xxxxx000100xxxxx0xxxx
20320                                                                 whilege.  */
20321                                                              return 2372;
20322                                                            }
20323                                                        }
20324                                                      else
20325                                                        {
20326                                                          if (((word >> 12) & 0x1) == 0)
20327                                                            {
20328                                                              /* 33222222222211111111110000000000
20329                                                                 10987654321098765432109876543210
20330                                                                 001001x1xx1xxxxx000010xxxxx0xxxx
20331                                                                 whilehs.  */
20332                                                              return 2377;
20333                                                            }
20334                                                          else
20335                                                            {
20336                                                              /* 33222222222211111111110000000000
20337                                                                 10987654321098765432109876543210
20338                                                                 001001x1xx1xxxxx000110xxxxx0xxxx
20339                                                                 whilehs.  */
20340                                                              return 2378;
20341                                                            }
20342                                                        }
20343                                                    }
20344                                                  else
20345                                                    {
20346                                                      if (((word >> 11) & 0x1) == 0)
20347                                                        {
20348                                                          if (((word >> 12) & 0x1) == 0)
20349                                                            {
20350                                                              /* 33222222222211111111110000000000
20351                                                                 10987654321098765432109876543210
20352                                                                 001001x1xx1xxxxx000001xxxxx0xxxx
20353                                                                 whilelt.  */
20354                                                              return 2083;
20355                                                            }
20356                                                          else
20357                                                            {
20358                                                              /* 33222222222211111111110000000000
20359                                                                 10987654321098765432109876543210
20360                                                                 001001x1xx1xxxxx000101xxxxx0xxxx
20361                                                                 whilelt.  */
20362                                                              return 2084;
20363                                                            }
20364                                                        }
20365                                                      else
20366                                                        {
20367                                                          if (((word >> 12) & 0x1) == 0)
20368                                                            {
20369                                                              /* 33222222222211111111110000000000
20370                                                                 10987654321098765432109876543210
20371                                                                 001001x1xx1xxxxx000011xxxxx0xxxx
20372                                                                 whilelo.  */
20373                                                              return 2079;
20374                                                            }
20375                                                          else
20376                                                            {
20377                                                              /* 33222222222211111111110000000000
20378                                                                 10987654321098765432109876543210
20379                                                                 001001x1xx1xxxxx000111xxxxx0xxxx
20380                                                                 whilelo.  */
20381                                                              return 2080;
20382                                                            }
20383                                                        }
20384                                                    }
20385                                                }
20386                                              else
20387                                                {
20388                                                  if (((word >> 10) & 0x1) == 0)
20389                                                    {
20390                                                      if (((word >> 11) & 0x1) == 0)
20391                                                        {
20392                                                          if (((word >> 12) & 0x1) == 0)
20393                                                            {
20394                                                              /* 33222222222211111111110000000000
20395                                                                 10987654321098765432109876543210
20396                                                                 001001x1xx1xxxxx000000xxxxx1xxxx
20397                                                                 whilegt.  */
20398                                                              return 2373;
20399                                                            }
20400                                                          else
20401                                                            {
20402                                                              /* 33222222222211111111110000000000
20403                                                                 10987654321098765432109876543210
20404                                                                 001001x1xx1xxxxx000100xxxxx1xxxx
20405                                                                 whilegt.  */
20406                                                              return 2374;
20407                                                            }
20408                                                        }
20409                                                      else
20410                                                        {
20411                                                          if (((word >> 12) & 0x1) == 0)
20412                                                            {
20413                                                              /* 33222222222211111111110000000000
20414                                                                 10987654321098765432109876543210
20415                                                                 001001x1xx1xxxxx000010xxxxx1xxxx
20416                                                                 whilehi.  */
20417                                                              return 2375;
20418                                                            }
20419                                                          else
20420                                                            {
20421                                                              /* 33222222222211111111110000000000
20422                                                                 10987654321098765432109876543210
20423                                                                 001001x1xx1xxxxx000110xxxxx1xxxx
20424                                                                 whilehi.  */
20425                                                              return 2376;
20426                                                            }
20427                                                        }
20428                                                    }
20429                                                  else
20430                                                    {
20431                                                      if (((word >> 11) & 0x1) == 0)
20432                                                        {
20433                                                          if (((word >> 12) & 0x1) == 0)
20434                                                            {
20435                                                              /* 33222222222211111111110000000000
20436                                                                 10987654321098765432109876543210
20437                                                                 001001x1xx1xxxxx000001xxxxx1xxxx
20438                                                                 whilele.  */
20439                                                              return 2077;
20440                                                            }
20441                                                          else
20442                                                            {
20443                                                              /* 33222222222211111111110000000000
20444                                                                 10987654321098765432109876543210
20445                                                                 001001x1xx1xxxxx000101xxxxx1xxxx
20446                                                                 whilele.  */
20447                                                              return 2078;
20448                                                            }
20449                                                        }
20450                                                      else
20451                                                        {
20452                                                          if (((word >> 12) & 0x1) == 0)
20453                                                            {
20454                                                              /* 33222222222211111111110000000000
20455                                                                 10987654321098765432109876543210
20456                                                                 001001x1xx1xxxxx000011xxxxx1xxxx
20457                                                                 whilels.  */
20458                                                              return 2081;
20459                                                            }
20460                                                          else
20461                                                            {
20462                                                              /* 33222222222211111111110000000000
20463                                                                 10987654321098765432109876543210
20464                                                                 001001x1xx1xxxxx000111xxxxx1xxxx
20465                                                                 whilels.  */
20466                                                              return 2082;
20467                                                            }
20468                                                        }
20469                                                    }
20470                                                }
20471                                            }
20472                                          else
20473                                            {
20474                                              if (((word >> 23) & 0x1) == 0)
20475                                                {
20476                                                  /* 33222222222211111111110000000000
20477                                                     10987654321098765432109876543210
20478                                                     101001x10x1xxxxx000xxxxxxxxxxxxx
20479                                                     ld1row.  */
20480                                                  return 3036;
20481                                                }
20482                                              else
20483                                                {
20484                                                  /* 33222222222211111111110000000000
20485                                                     10987654321098765432109876543210
20486                                                     101001x11x1xxxxx000xxxxxxxxxxxxx
20487                                                     ld1rod.  */
20488                                                  return 3037;
20489                                                }
20490                                            }
20491                                        }
20492                                    }
20493                                  else
20494                                    {
20495                                      if (((word >> 31) & 0x1) == 0)
20496                                        {
20497                                          if (((word >> 21) & 0x1) == 0)
20498                                            {
20499                                              if (((word >> 10) & 0x1) == 0)
20500                                                {
20501                                                  if (((word >> 11) & 0x1) == 0)
20502                                                    {
20503                                                      /* 33222222222211111111110000000000
20504                                                         10987654321098765432109876543210
20505                                                         011001x1xx0xxxxx000x00xxxxxxxxxx
20506                                                         fadd.  */
20507                                                      return 1434;
20508                                                    }
20509                                                  else
20510                                                    {
20511                                                      if (((word >> 12) & 0x1) == 0)
20512                                                        {
20513                                                          /* 33222222222211111111110000000000
20514                                                             10987654321098765432109876543210
20515                                                             011001x1xx0xxxxx000010xxxxxxxxxx
20516                                                             fmul.  */
20517                                                          return 1501;
20518                                                        }
20519                                                      else
20520                                                        {
20521                                                          /* 33222222222211111111110000000000
20522                                                             10987654321098765432109876543210
20523                                                             011001x1xx0xxxxx000110xxxxxxxxxx
20524                                                             frecps.  */
20525                                                          return 1514;
20526                                                        }
20527                                                    }
20528                                                }
20529                                              else
20530                                                {
20531                                                  if (((word >> 11) & 0x1) == 0)
20532                                                    {
20533                                                      /* 33222222222211111111110000000000
20534                                                         10987654321098765432109876543210
20535                                                         011001x1xx0xxxxx000x01xxxxxxxxxx
20536                                                         fsub.  */
20537                                                      return 1527;
20538                                                    }
20539                                                  else
20540                                                    {
20541                                                      if (((word >> 12) & 0x1) == 0)
20542                                                        {
20543                                                          /* 33222222222211111111110000000000
20544                                                             10987654321098765432109876543210
20545                                                             011001x1xx0xxxxx000011xxxxxxxxxx
20546                                                             ftsmul.  */
20547                                                          return 1533;
20548                                                        }
20549                                                      else
20550                                                        {
20551                                                          /* 33222222222211111111110000000000
20552                                                             10987654321098765432109876543210
20553                                                             011001x1xx0xxxxx000111xxxxxxxxxx
20554                                                             frsqrts.  */
20555                                                          return 1524;
20556                                                        }
20557                                                    }
20558                                                }
20559                                            }
20560                                          else
20561                                            {
20562                                              /* 33222222222211111111110000000000
20563                                                 10987654321098765432109876543210
20564                                                 011001x1xx1xxxxx000xxxxxxxxxxxxx
20565                                                 fmla.  */
20566                                              return 1492;
20567                                            }
20568                                        }
20569                                      else
20570                                        {
20571                                          /* 33222222222211111111110000000000
20572                                             10987654321098765432109876543210
20573                                             111001x1xxxxxxxx000xxxxxxxxxxxxx
20574                                             str.  */
20575                                          return 1997;
20576                                        }
20577                                    }
20578                                }
20579                              else
20580                                {
20581                                  if (((word >> 21) & 0x1) == 0)
20582                                    {
20583                                      if (((word >> 30) & 0x1) == 0)
20584                                        {
20585                                          if (((word >> 31) & 0x1) == 0)
20586                                            {
20587                                              if (((word >> 4) & 0x1) == 0)
20588                                                {
20589                                                  /* 33222222222211111111110000000000
20590                                                     10987654321098765432109876543210
20591                                                     001001x1xx0xxxxx001xxxxxxxx0xxxx
20592                                                     cmplt.  */
20593                                                  return 1393;
20594                                                }
20595                                              else
20596                                                {
20597                                                  /* 33222222222211111111110000000000
20598                                                     10987654321098765432109876543210
20599                                                     001001x1xx0xxxxx001xxxxxxxx1xxxx
20600                                                     cmple.  */
20601                                                  return 1387;
20602                                                }
20603                                            }
20604                                          else
20605                                            {
20606                                              if (((word >> 23) & 0x1) == 0)
20607                                                {
20608                                                  /* 33222222222211111111110000000000
20609                                                     10987654321098765432109876543210
20610                                                     101001x10x0xxxxx001xxxxxxxxxxxxx
20611                                                     ld1rqw.  */
20612                                                  return 1602;
20613                                                }
20614                                              else
20615                                                {
20616                                                  /* 33222222222211111111110000000000
20617                                                     10987654321098765432109876543210
20618                                                     101001x11x0xxxxx001xxxxxxxxxxxxx
20619                                                     ld1rqd.  */
20620                                                  return 1598;
20621                                                }
20622                                            }
20623                                        }
20624                                      else
20625                                        {
20626                                          if (((word >> 31) & 0x1) == 0)
20627                                            {
20628                                              if (((word >> 16) & 0x1) == 0)
20629                                                {
20630                                                  if (((word >> 17) & 0x1) == 0)
20631                                                    {
20632                                                      if (((word >> 18) & 0x1) == 0)
20633                                                        {
20634                                                          if (((word >> 19) & 0x1) == 0)
20635                                                            {
20636                                                              if (((word >> 20) & 0x1) == 0)
20637                                                                {
20638                                                                  /* 33222222222211111111110000000000
20639                                                                     10987654321098765432109876543210
20640                                                                     011001x1xx000000001xxxxxxxxxxxxx
20641                                                                     faddv.  */
20642                                                                  return 1438;
20643                                                                }
20644                                                              else
20645                                                                {
20646                                                                  if (((word >> 4) & 0x1) == 0)
20647                                                                    {
20648                                                                      /* 33222222222211111111110000000000
20649                                                                         10987654321098765432109876543210
20650                                                                         011001x1xx010000001xxxxxxxx0xxxx
20651                                                                         fcmge.  */
20652                                                                      return 1445;
20653                                                                    }
20654                                                                  else
20655                                                                    {
20656                                                                      /* 33222222222211111111110000000000
20657                                                                         10987654321098765432109876543210
20658                                                                         011001x1xx010000001xxxxxxxx1xxxx
20659                                                                         fcmgt.  */
20660                                                                      return 1447;
20661                                                                    }
20662                                                                }
20663                                                            }
20664                                                          else
20665                                                            {
20666                                                              /* 33222222222211111111110000000000
20667                                                                 10987654321098765432109876543210
20668                                                                 011001x1xx0x1000001xxxxxxxxxxxxx
20669                                                                 fadda.  */
20670                                                              return 1437;
20671                                                            }
20672                                                        }
20673                                                      else
20674                                                        {
20675                                                          /* 33222222222211111111110000000000
20676                                                             10987654321098765432109876543210
20677                                                             011001x1xx0xx100001xxxxxxxxxxxxx
20678                                                             fmaxnmv.  */
20679                                                          return 1484;
20680                                                        }
20681                                                    }
20682                                                  else
20683                                                    {
20684                                                      if (((word >> 18) & 0x1) == 0)
20685                                                        {
20686                                                          /* 33222222222211111111110000000000
20687                                                             10987654321098765432109876543210
20688                                                             011001x1xx0xx010001xxxxxxxxxxxxx
20689                                                             fcmeq.  */
20690                                                          return 1443;
20691                                                        }
20692                                                      else
20693                                                        {
20694                                                          if (((word >> 19) & 0x1) == 0)
20695                                                            {
20696                                                              /* 33222222222211111111110000000000
20697                                                                 10987654321098765432109876543210
20698                                                                 011001x1xx0x0110001xxxxxxxxxxxxx
20699                                                                 fmaxv.  */
20700                                                              return 1485;
20701                                                            }
20702                                                          else
20703                                                            {
20704                                                              /* 33222222222211111111110000000000
20705                                                                 10987654321098765432109876543210
20706                                                                 011001x1xx0x1110001xxxxxxxxxxxxx
20707                                                                 frecpe.  */
20708                                                              return 1513;
20709                                                            }
20710                                                        }
20711                                                    }
20712                                                }
20713                                              else
20714                                                {
20715                                                  if (((word >> 17) & 0x1) == 0)
20716                                                    {
20717                                                      if (((word >> 18) & 0x1) == 0)
20718                                                        {
20719                                                          if (((word >> 4) & 0x1) == 0)
20720                                                            {
20721                                                              /* 33222222222211111111110000000000
20722                                                                 10987654321098765432109876543210
20723                                                                 011001x1xx0xx001001xxxxxxxx0xxxx
20724                                                                 fcmlt.  */
20725                                                              return 1450;
20726                                                            }
20727                                                          else
20728                                                            {
20729                                                              /* 33222222222211111111110000000000
20730                                                                 10987654321098765432109876543210
20731                                                                 011001x1xx0xx001001xxxxxxxx1xxxx
20732                                                                 fcmle.  */
20733                                                              return 1449;
20734                                                            }
20735                                                        }
20736                                                      else
20737                                                        {
20738                                                          /* 33222222222211111111110000000000
20739                                                             10987654321098765432109876543210
20740                                                             011001x1xx0xx101001xxxxxxxxxxxxx
20741                                                             fminnmv.  */
20742                                                          return 1490;
20743                                                        }
20744                                                    }
20745                                                  else
20746                                                    {
20747                                                      if (((word >> 18) & 0x1) == 0)
20748                                                        {
20749                                                          /* 33222222222211111111110000000000
20750                                                             10987654321098765432109876543210
20751                                                             011001x1xx0xx011001xxxxxxxxxxxxx
20752                                                             fcmne.  */
20753                                                          return 1451;
20754                                                        }
20755                                                      else
20756                                                        {
20757                                                          if (((word >> 19) & 0x1) == 0)
20758                                                            {
20759                                                              /* 33222222222211111111110000000000
20760                                                                 10987654321098765432109876543210
20761                                                                 011001x1xx0x0111001xxxxxxxxxxxxx
20762                                                                 fminv.  */
20763                                                              return 1491;
20764                                                            }
20765                                                          else
20766                                                            {
20767                                                              /* 33222222222211111111110000000000
20768                                                                 10987654321098765432109876543210
20769                                                                 011001x1xx0x1111001xxxxxxxxxxxxx
20770                                                                 frsqrte.  */
20771                                                              return 1523;
20772                                                            }
20773                                                        }
20774                                                    }
20775                                                }
20776                                            }
20777                                          else
20778                                            {
20779                                              if (((word >> 22) & 0x1) == 0)
20780                                                {
20781                                                  if (((word >> 23) & 0x1) == 0)
20782                                                    {
20783                                                      /* 33222222222211111111110000000000
20784                                                         10987654321098765432109876543210
20785                                                         111001x1000xxxxx001xxxxxxxxxxxxx
20786                                                         stnt1w.  */
20787                                                      return 2302;
20788                                                    }
20789                                                  else
20790                                                    {
20791                                                      /* 33222222222211111111110000000000
20792                                                         10987654321098765432109876543210
20793                                                         111001x1100xxxxx001xxxxxxxxxxxxx
20794                                                         stnt1d.  */
20795                                                      return 2298;
20796                                                    }
20797                                                }
20798                                              else
20799                                                {
20800                                                  /* 33222222222211111111110000000000
20801                                                     10987654321098765432109876543210
20802                                                     111001x1x10xxxxx001xxxxxxxxxxxxx
20803                                                     stnt1w.  */
20804                                                  return 2301;
20805                                                }
20806                                            }
20807                                        }
20808                                    }
20809                                  else
20810                                    {
20811                                      if (((word >> 30) & 0x1) == 0)
20812                                        {
20813                                          if (((word >> 31) & 0x1) == 0)
20814                                            {
20815                                              if (((word >> 4) & 0x1) == 0)
20816                                                {
20817                                                  if (((word >> 12) & 0x1) == 0)
20818                                                    {
20819                                                      /* 33222222222211111111110000000000
20820                                                         10987654321098765432109876543210
20821                                                         001001x1xx1xxxxx0010xxxxxxx0xxxx
20822                                                         ctermeq.  */
20823                                                      return 1408;
20824                                                    }
20825                                                  else
20826                                                    {
20827                                                      /* 33222222222211111111110000000000
20828                                                         10987654321098765432109876543210
20829                                                         001001x1xx1xxxxx0011xxxxxxx0xxxx
20830                                                         whilewr.  */
20831                                                      return 2380;
20832                                                    }
20833                                                }
20834                                              else
20835                                                {
20836                                                  if (((word >> 12) & 0x1) == 0)
20837                                                    {
20838                                                      /* 33222222222211111111110000000000
20839                                                         10987654321098765432109876543210
20840                                                         001001x1xx1xxxxx0010xxxxxxx1xxxx
20841                                                         ctermne.  */
20842                                                      return 1409;
20843                                                    }
20844                                                  else
20845                                                    {
20846                                                      /* 33222222222211111111110000000000
20847                                                         10987654321098765432109876543210
20848                                                         001001x1xx1xxxxx0011xxxxxxx1xxxx
20849                                                         whilerw.  */
20850                                                      return 2379;
20851                                                    }
20852                                                }
20853                                            }
20854                                          else
20855                                            {
20856                                              if (((word >> 23) & 0x1) == 0)
20857                                                {
20858                                                  /* 33222222222211111111110000000000
20859                                                     10987654321098765432109876543210
20860                                                     101001x10x1xxxxx001xxxxxxxxxxxxx
20861                                                     ld1row.  */
20862                                                  return 3040;
20863                                                }
20864                                              else
20865                                                {
20866                                                  /* 33222222222211111111110000000000
20867                                                     10987654321098765432109876543210
20868                                                     101001x11x1xxxxx001xxxxxxxxxxxxx
20869                                                     ld1rod.  */
20870                                                  return 3041;
20871                                                }
20872                                            }
20873                                        }
20874                                      else
20875                                        {
20876                                          /* 33222222222211111111110000000000
20877                                             10987654321098765432109876543210
20878                                             x11001x1xx1xxxxx001xxxxxxxxxxxxx
20879                                             fmls.  */
20880                                          return 1496;
20881                                        }
20882                                    }
20883                                }
20884                            }
20885                          else
20886                            {
20887                              if (((word >> 30) & 0x1) == 0)
20888                                {
20889                                  if (((word >> 21) & 0x1) == 0)
20890                                    {
20891                                      if (((word >> 22) & 0x1) == 0)
20892                                        {
20893                                          if (((word >> 23) & 0x1) == 0)
20894                                            {
20895                                              if (((word >> 31) & 0x1) == 0)
20896                                                {
20897                                                  if (((word >> 9) & 0x1) == 0)
20898                                                    {
20899                                                      if (((word >> 20) & 0x1) == 0)
20900                                                        {
20901                                                          if (((word >> 4) & 0x1) == 0)
20902                                                            {
20903                                                              /* 33222222222211111111110000000000
20904                                                                 10987654321098765432109876543210
20905                                                                 001001x10000xxxx01xxxx0xxxx0xxxx
20906                                                                 and.  */
20907                                                              return 1339;
20908                                                            }
20909                                                          else
20910                                                            {
20911                                                              /* 33222222222211111111110000000000
20912                                                                 10987654321098765432109876543210
20913                                                                 001001x10000xxxx01xxxx0xxxx1xxxx
20914                                                                 bic.  */
20915                                                              return 1351;
20916                                                            }
20917                                                        }
20918                                                      else
20919                                                        {
20920                                                          if (((word >> 19) & 0x1) == 0)
20921                                                            {
20922                                                              /* 33222222222211111111110000000000
20923                                                                 10987654321098765432109876543210
20924                                                                 001001x100010xxx01xxxx0xxxxxxxxx
20925                                                                 brka.  */
20926                                                              return 1353;
20927                                                            }
20928                                                          else
20929                                                            {
20930                                                              /* 33222222222211111111110000000000
20931                                                                 10987654321098765432109876543210
20932                                                                 001001x100011xxx01xxxx0xxxxxxxxx
20933                                                                 brkn.  */
20934                                                              return 1357;
20935                                                            }
20936                                                        }
20937                                                    }
20938                                                  else
20939                                                    {
20940                                                      if (((word >> 4) & 0x1) == 0)
20941                                                        {
20942                                                          /* 33222222222211111111110000000000
20943                                                             10987654321098765432109876543210
20944                                                             001001x1000xxxxx01xxxx1xxxx0xxxx
20945                                                             eor.  */
20946                                                          return 1426;
20947                                                        }
20948                                                      else
20949                                                        {
20950                                                          /* 33222222222211111111110000000000
20951                                                             10987654321098765432109876543210
20952                                                             001001x1000xxxxx01xxxx1xxxx1xxxx
20953                                                             sel.  */
20954                                                          return 1877;
20955                                                        }
20956                                                    }
20957                                                }
20958                                              else
20959                                                {
20960                                                  if (((word >> 13) & 0x1) == 0)
20961                                                    {
20962                                                      /* 33222222222211111111110000000000
20963                                                         10987654321098765432109876543210
20964                                                         101001x1000xxxxx010xxxxxxxxxxxxx
20965                                                         ld1sh.  */
20966                                                      return 1625;
20967                                                    }
20968                                                  else
20969                                                    {
20970                                                      /* 33222222222211111111110000000000
20971                                                         10987654321098765432109876543210
20972                                                         101001x1000xxxxx011xxxxxxxxxxxxx
20973                                                         ldff1sh.  */
20974                                                      return 1725;
20975                                                    }
20976                                                }
20977                                            }
20978                                          else
20979                                            {
20980                                              if (((word >> 31) & 0x1) == 0)
20981                                                {
20982                                                  if (((word >> 9) & 0x1) == 0)
20983                                                    {
20984                                                      if (((word >> 20) & 0x1) == 0)
20985                                                        {
20986                                                          if (((word >> 4) & 0x1) == 0)
20987                                                            {
20988                                                              /* 33222222222211111111110000000000
20989                                                                 10987654321098765432109876543210
20990                                                                 001001x11000xxxx01xxxx0xxxx0xxxx
20991                                                                 orr.  */
20992                                                              return 1812;
20993                                                            }
20994                                                          else
20995                                                            {
20996                                                              /* 33222222222211111111110000000000
20997                                                                 10987654321098765432109876543210
20998                                                                 001001x11000xxxx01xxxx0xxxx1xxxx
20999                                                                 orn.  */
21000                                                              return 1807;
21001                                                            }
21002                                                        }
21003                                                      else
21004                                                        {
21005                                                          /* 33222222222211111111110000000000
21006                                                             10987654321098765432109876543210
21007                                                             001001x11001xxxx01xxxx0xxxxxxxxx
21008                                                             brkb.  */
21009                                                          return 1355;
21010                                                        }
21011                                                    }
21012                                                  else
21013                                                    {
21014                                                      if (((word >> 4) & 0x1) == 0)
21015                                                        {
21016                                                          /* 33222222222211111111110000000000
21017                                                             10987654321098765432109876543210
21018                                                             001001x1100xxxxx01xxxx1xxxx0xxxx
21019                                                             nor.  */
21020                                                          return 1804;
21021                                                        }
21022                                                      else
21023                                                        {
21024                                                          /* 33222222222211111111110000000000
21025                                                             10987654321098765432109876543210
21026                                                             001001x1100xxxxx01xxxx1xxxx1xxxx
21027                                                             nand.  */
21028                                                          return 1801;
21029                                                        }
21030                                                    }
21031                                                }
21032                                              else
21033                                                {
21034                                                  if (((word >> 13) & 0x1) == 0)
21035                                                    {
21036                                                      /* 33222222222211111111110000000000
21037                                                         10987654321098765432109876543210
21038                                                         101001x1100xxxxx010xxxxxxxxxxxxx
21039                                                         ld1sb.  */
21040                                                      return 1613;
21041                                                    }
21042                                                  else
21043                                                    {
21044                                                      /* 33222222222211111111110000000000
21045                                                         10987654321098765432109876543210
21046                                                         101001x1100xxxxx011xxxxxxxxxxxxx
21047                                                         ldff1sb.  */
21048                                                      return 1713;
21049                                                    }
21050                                                }
21051                                            }
21052                                        }
21053                                      else
21054                                        {
21055                                          if (((word >> 23) & 0x1) == 0)
21056                                            {
21057                                              if (((word >> 31) & 0x1) == 0)
21058                                                {
21059                                                  if (((word >> 4) & 0x1) == 0)
21060                                                    {
21061                                                      if (((word >> 9) & 0x1) == 0)
21062                                                        {
21063                                                          if (((word >> 20) & 0x1) == 0)
21064                                                            {
21065                                                              /* 33222222222211111111110000000000
21066                                                                 10987654321098765432109876543210
21067                                                                 001001x10100xxxx01xxxx0xxxx0xxxx
21068                                                                 ands.  */
21069                                                              return 1340;
21070                                                            }
21071                                                          else
21072                                                            {
21073                                                              if (((word >> 19) & 0x1) == 0)
21074                                                                {
21075                                                                  /* 33222222222211111111110000000000
21076                                                                     10987654321098765432109876543210
21077                                                                     001001x101010xxx01xxxx0xxxx0xxxx
21078                                                                     brkas.  */
21079                                                                  return 1354;
21080                                                                }
21081                                                              else
21082                                                                {
21083                                                                  /* 33222222222211111111110000000000
21084                                                                     10987654321098765432109876543210
21085                                                                     001001x101011xxx01xxxx0xxxx0xxxx
21086                                                                     brkns.  */
21087                                                                  return 1358;
21088                                                                }
21089                                                            }
21090                                                        }
21091                                                      else
21092                                                        {
21093                                                          /* 33222222222211111111110000000000
21094                                                             10987654321098765432109876543210
21095                                                             001001x1010xxxxx01xxxx1xxxx0xxxx
21096                                                             eors.  */
21097                                                          return 1427;
21098                                                        }
21099                                                    }
21100                                                  else
21101                                                    {
21102                                                      /* 33222222222211111111110000000000
21103                                                         10987654321098765432109876543210
21104                                                         001001x1010xxxxx01xxxxxxxxx1xxxx
21105                                                         bics.  */
21106                                                      return 1352;
21107                                                    }
21108                                                }
21109                                              else
21110                                                {
21111                                                  if (((word >> 13) & 0x1) == 0)
21112                                                    {
21113                                                      /* 33222222222211111111110000000000
21114                                                         10987654321098765432109876543210
21115                                                         101001x1010xxxxx010xxxxxxxxxxxxx
21116                                                         ld1w.  */
21117                                                      return 1644;
21118                                                    }
21119                                                  else
21120                                                    {
21121                                                      /* 33222222222211111111110000000000
21122                                                         10987654321098765432109876543210
21123                                                         101001x1010xxxxx011xxxxxxxxxxxxx
21124                                                         ldff1w.  */
21125                                                      return 1744;
21126                                                    }
21127                                                }
21128                                            }
21129                                          else
21130                                            {
21131                                              if (((word >> 31) & 0x1) == 0)
21132                                                {
21133                                                  if (((word >> 4) & 0x1) == 0)
21134                                                    {
21135                                                      if (((word >> 9) & 0x1) == 0)
21136                                                        {
21137                                                          if (((word >> 20) & 0x1) == 0)
21138                                                            {
21139                                                              /* 33222222222211111111110000000000
21140                                                                 10987654321098765432109876543210
21141                                                                 001001x11100xxxx01xxxx0xxxx0xxxx
21142                                                                 orrs.  */
21143                                                              return 1813;
21144                                                            }
21145                                                          else
21146                                                            {
21147                                                              /* 33222222222211111111110000000000
21148                                                                 10987654321098765432109876543210
21149                                                                 001001x11101xxxx01xxxx0xxxx0xxxx
21150                                                                 brkbs.  */
21151                                                              return 1356;
21152                                                            }
21153                                                        }
21154                                                      else
21155                                                        {
21156                                                          /* 33222222222211111111110000000000
21157                                                             10987654321098765432109876543210
21158                                                             001001x1110xxxxx01xxxx1xxxx0xxxx
21159                                                             nors.  */
21160                                                          return 1805;
21161                                                        }
21162                                                    }
21163                                                  else
21164                                                    {
21165                                                      if (((word >> 9) & 0x1) == 0)
21166                                                        {
21167                                                          /* 33222222222211111111110000000000
21168                                                             10987654321098765432109876543210
21169                                                             001001x1110xxxxx01xxxx0xxxx1xxxx
21170                                                             orns.  */
21171                                                          return 1808;
21172                                                        }
21173                                                      else
21174                                                        {
21175                                                          /* 33222222222211111111110000000000
21176                                                             10987654321098765432109876543210
21177                                                             001001x1110xxxxx01xxxx1xxxx1xxxx
21178                                                             nands.  */
21179                                                          return 1802;
21180                                                        }
21181                                                    }
21182                                                }
21183                                              else
21184                                                {
21185                                                  if (((word >> 13) & 0x1) == 0)
21186                                                    {
21187                                                      /* 33222222222211111111110000000000
21188                                                         10987654321098765432109876543210
21189                                                         101001x1110xxxxx010xxxxxxxxxxxxx
21190                                                         ld1sb.  */
21191                                                      return 1615;
21192                                                    }
21193                                                  else
21194                                                    {
21195                                                      /* 33222222222211111111110000000000
21196                                                         10987654321098765432109876543210
21197                                                         101001x1110xxxxx011xxxxxxxxxxxxx
21198                                                         ldff1sb.  */
21199                                                      return 1717;
21200                                                    }
21201                                                }
21202                                            }
21203                                        }
21204                                    }
21205                                  else
21206                                    {
21207                                      if (((word >> 31) & 0x1) == 0)
21208                                        {
21209                                          if (((word >> 4) & 0x1) == 0)
21210                                            {
21211                                              /* 33222222222211111111110000000000
21212                                                 10987654321098765432109876543210
21213                                                 001001x1xx1xxxxx01xxxxxxxxx0xxxx
21214                                                 psel.  */
21215                                              return 2455;
21216                                            }
21217                                          else
21218                                            {
21219                                              if (((word >> 10) & 0x1) == 0)
21220                                                {
21221                                                  if (((word >> 11) & 0x1) == 0)
21222                                                    {
21223                                                      if (((word >> 12) & 0x1) == 0)
21224                                                        {
21225                                                          if (((word >> 3) & 0x1) == 0)
21226                                                            {
21227                                                              /* 33222222222211111111110000000000
21228                                                                 10987654321098765432109876543210
21229                                                                 001001x1xx1xxxxx01x000xxxxx10xxx
21230                                                                 whilege.  */
21231                                                              return 2938;
21232                                                            }
21233                                                          else
21234                                                            {
21235                                                              /* 33222222222211111111110000000000
21236                                                                 10987654321098765432109876543210
21237                                                                 001001x1xx1xxxxx01x000xxxxx11xxx
21238                                                                 whilegt.  */
21239                                                              return 2939;
21240                                                            }
21241                                                        }
21242                                                      else
21243                                                        {
21244                                                          if (((word >> 13) & 0x1) == 0)
21245                                                            {
21246                                                              if (((word >> 0) & 0x1) == 0)
21247                                                                {
21248                                                                  /* 33222222222211111111110000000000
21249                                                                     10987654321098765432109876543210
21250                                                                     001001x1xx1xxxxx010100xxxxx1xxx0
21251                                                                     whilege.  */
21252                                                                  return 2475;
21253                                                                }
21254                                                              else
21255                                                                {
21256                                                                  /* 33222222222211111111110000000000
21257                                                                     10987654321098765432109876543210
21258                                                                     001001x1xx1xxxxx010100xxxxx1xxx1
21259                                                                     whilegt.  */
21260                                                                  return 2476;
21261                                                                }
21262                                                            }
21263                                                          else
21264                                                            {
21265                                                              /* 33222222222211111111110000000000
21266                                                                 10987654321098765432109876543210
21267                                                                 001001x1xx1xxxxx011100xxxxx1xxxx
21268                                                                 pext.  */
21269                                                              return 2679;
21270                                                            }
21271                                                        }
21272                                                    }
21273                                                  else
21274                                                    {
21275                                                      if (((word >> 12) & 0x1) == 0)
21276                                                        {
21277                                                          if (((word >> 3) & 0x1) == 0)
21278                                                            {
21279                                                              /* 33222222222211111111110000000000
21280                                                                 10987654321098765432109876543210
21281                                                                 001001x1xx1xxxxx01x010xxxxx10xxx
21282                                                                 whilehs.  */
21283                                                              return 2941;
21284                                                            }
21285                                                          else
21286                                                            {
21287                                                              /* 33222222222211111111110000000000
21288                                                                 10987654321098765432109876543210
21289                                                                 001001x1xx1xxxxx01x010xxxxx11xxx
21290                                                                 whilehi.  */
21291                                                              return 2940;
21292                                                            }
21293                                                        }
21294                                                      else
21295                                                        {
21296                                                          if (((word >> 13) & 0x1) == 0)
21297                                                            {
21298                                                              if (((word >> 0) & 0x1) == 0)
21299                                                                {
21300                                                                  /* 33222222222211111111110000000000
21301                                                                     10987654321098765432109876543210
21302                                                                     001001x1xx1xxxxx010110xxxxx1xxx0
21303                                                                     whilehs.  */
21304                                                                  return 2478;
21305                                                                }
21306                                                              else
21307                                                                {
21308                                                                  /* 33222222222211111111110000000000
21309                                                                     10987654321098765432109876543210
21310                                                                     001001x1xx1xxxxx010110xxxxx1xxx1
21311                                                                     whilehi.  */
21312                                                                  return 2477;
21313                                                                }
21314                                                            }
21315                                                          else
21316                                                            {
21317                                                              /* 33222222222211111111110000000000
21318                                                                 10987654321098765432109876543210
21319                                                                 001001x1xx1xxxxx011110xxxxx1xxxx
21320                                                                 ptrue.  */
21321                                                              return 2681;
21322                                                            }
21323                                                        }
21324                                                    }
21325                                                }
21326                                              else
21327                                                {
21328                                                  if (((word >> 11) & 0x1) == 0)
21329                                                    {
21330                                                      if (((word >> 12) & 0x1) == 0)
21331                                                        {
21332                                                          if (((word >> 3) & 0x1) == 0)
21333                                                            {
21334                                                              /* 33222222222211111111110000000000
21335                                                                 10987654321098765432109876543210
21336                                                                 001001x1xx1xxxxx01x001xxxxx10xxx
21337                                                                 whilelt.  */
21338                                                              return 2945;
21339                                                            }
21340                                                          else
21341                                                            {
21342                                                              /* 33222222222211111111110000000000
21343                                                                 10987654321098765432109876543210
21344                                                                 001001x1xx1xxxxx01x001xxxxx11xxx
21345                                                                 whilele.  */
21346                                                              return 2942;
21347                                                            }
21348                                                        }
21349                                                      else
21350                                                        {
21351                                                          if (((word >> 13) & 0x1) == 0)
21352                                                            {
21353                                                              if (((word >> 0) & 0x1) == 0)
21354                                                                {
21355                                                                  /* 33222222222211111111110000000000
21356                                                                     10987654321098765432109876543210
21357                                                                     001001x1xx1xxxxx010101xxxxx1xxx0
21358                                                                     whilelt.  */
21359                                                                  return 2482;
21360                                                                }
21361                                                              else
21362                                                                {
21363                                                                  /* 33222222222211111111110000000000
21364                                                                     10987654321098765432109876543210
21365                                                                     001001x1xx1xxxxx010101xxxxx1xxx1
21366                                                                     whilele.  */
21367                                                                  return 2479;
21368                                                                }
21369                                                            }
21370                                                          else
21371                                                            {
21372                                                              /* 33222222222211111111110000000000
21373                                                                 10987654321098765432109876543210
21374                                                                 001001x1xx1xxxxx011101xxxxx1xxxx
21375                                                                 pext.  */
21376                                                              return 2680;
21377                                                            }
21378                                                        }
21379                                                    }
21380                                                  else
21381                                                    {
21382                                                      if (((word >> 12) & 0x1) == 0)
21383                                                        {
21384                                                          if (((word >> 3) & 0x1) == 0)
21385                                                            {
21386                                                              /* 33222222222211111111110000000000
21387                                                                 10987654321098765432109876543210
21388                                                                 001001x1xx1xxxxx01x011xxxxx10xxx
21389                                                                 whilelo.  */
21390                                                              return 2943;
21391                                                            }
21392                                                          else
21393                                                            {
21394                                                              /* 33222222222211111111110000000000
21395                                                                 10987654321098765432109876543210
21396                                                                 001001x1xx1xxxxx01x011xxxxx11xxx
21397                                                                 whilels.  */
21398                                                              return 2944;
21399                                                            }
21400                                                        }
21401                                                      else
21402                                                        {
21403                                                          if (((word >> 0) & 0x1) == 0)
21404                                                            {
21405                                                              /* 33222222222211111111110000000000
21406                                                                 10987654321098765432109876543210
21407                                                                 001001x1xx1xxxxx01x111xxxxx1xxx0
21408                                                                 whilelo.  */
21409                                                              return 2480;
21410                                                            }
21411                                                          else
21412                                                            {
21413                                                              /* 33222222222211111111110000000000
21414                                                                 10987654321098765432109876543210
21415                                                                 001001x1xx1xxxxx01x111xxxxx1xxx1
21416                                                                 whilels.  */
21417                                                              return 2481;
21418                                                            }
21419                                                        }
21420                                                    }
21421                                                }
21422                                            }
21423                                        }
21424                                      else
21425                                        {
21426                                          if (((word >> 13) & 0x1) == 0)
21427                                            {
21428                                              if (((word >> 22) & 0x1) == 0)
21429                                                {
21430                                                  if (((word >> 23) & 0x1) == 0)
21431                                                    {
21432                                                      /* 33222222222211111111110000000000
21433                                                         10987654321098765432109876543210
21434                                                         101001x1001xxxxx010xxxxxxxxxxxxx
21435                                                         ld1sh.  */
21436                                                      return 1626;
21437                                                    }
21438                                                  else
21439                                                    {
21440                                                      /* 33222222222211111111110000000000
21441                                                         10987654321098765432109876543210
21442                                                         101001x1101xxxxx010xxxxxxxxxxxxx
21443                                                         ld1sb.  */
21444                                                      return 1614;
21445                                                    }
21446                                                }
21447                                              else
21448                                                {
21449                                                  if (((word >> 23) & 0x1) == 0)
21450                                                    {
21451                                                      /* 33222222222211111111110000000000
21452                                                         10987654321098765432109876543210
21453                                                         101001x1011xxxxx010xxxxxxxxxxxxx
21454                                                         ld1w.  */
21455                                                      return 1645;
21456                                                    }
21457                                                  else
21458                                                    {
21459                                                      /* 33222222222211111111110000000000
21460                                                         10987654321098765432109876543210
21461                                                         101001x1111xxxxx010xxxxxxxxxxxxx
21462                                                         ld1d.  */
21463                                                      return 1567;
21464                                                    }
21465                                                }
21466                                            }
21467                                          else
21468                                            {
21469                                              if (((word >> 22) & 0x1) == 0)
21470                                                {
21471                                                  if (((word >> 23) & 0x1) == 0)
21472                                                    {
21473                                                      /* 33222222222211111111110000000000
21474                                                         10987654321098765432109876543210
21475                                                         101001x1001xxxxx011xxxxxxxxxxxxx
21476                                                         ldff1sh.  */
21477                                                      return 1727;
21478                                                    }
21479                                                  else
21480                                                    {
21481                                                      /* 33222222222211111111110000000000
21482                                                         10987654321098765432109876543210
21483                                                         101001x1101xxxxx011xxxxxxxxxxxxx
21484                                                         ldff1sb.  */
21485                                                      return 1715;
21486                                                    }
21487                                                }
21488                                              else
21489                                                {
21490                                                  if (((word >> 23) & 0x1) == 0)
21491                                                    {
21492                                                      /* 33222222222211111111110000000000
21493                                                         10987654321098765432109876543210
21494                                                         101001x1011xxxxx011xxxxxxxxxxxxx
21495                                                         ldff1w.  */
21496                                                      return 1746;
21497                                                    }
21498                                                  else
21499                                                    {
21500                                                      /* 33222222222211111111110000000000
21501                                                         10987654321098765432109876543210
21502                                                         101001x1111xxxxx011xxxxxxxxxxxxx
21503                                                         ldff1d.  */
21504                                                      return 1691;
21505                                                    }
21506                                                }
21507                                            }
21508                                        }
21509                                    }
21510                                }
21511                              else
21512                                {
21513                                  if (((word >> 13) & 0x1) == 0)
21514                                    {
21515                                      if (((word >> 31) & 0x1) == 0)
21516                                        {
21517                                          if (((word >> 21) & 0x1) == 0)
21518                                            {
21519                                              if (((word >> 4) & 0x1) == 0)
21520                                                {
21521                                                  /* 33222222222211111111110000000000
21522                                                     10987654321098765432109876543210
21523                                                     011001x1xx0xxxxx010xxxxxxxx0xxxx
21524                                                     fcmge.  */
21525                                                  return 1446;
21526                                                }
21527                                              else
21528                                                {
21529                                                  /* 33222222222211111111110000000000
21530                                                     10987654321098765432109876543210
21531                                                     011001x1xx0xxxxx010xxxxxxxx1xxxx
21532                                                     fcmgt.  */
21533                                                  return 1448;
21534                                                }
21535                                            }
21536                                          else
21537                                            {
21538                                              /* 33222222222211111111110000000000
21539                                                 10987654321098765432109876543210
21540                                                 011001x1xx1xxxxx010xxxxxxxxxxxxx
21541                                                 fnmla.  */
21542                                              return 1510;
21543                                            }
21544                                        }
21545                                      else
21546                                        {
21547                                          if (((word >> 22) & 0x1) == 0)
21548                                            {
21549                                              /* 33222222222211111111110000000000
21550                                                 10987654321098765432109876543210
21551                                                 111001x1x0xxxxxx010xxxxxxxxxxxxx
21552                                                 str.  */
21553                                              return 1999;
21554                                            }
21555                                          else
21556                                            {
21557                                              if (((word >> 21) & 0x1) == 0)
21558                                                {
21559                                                  /* 33222222222211111111110000000000
21560                                                     10987654321098765432109876543210
21561                                                     111001x1x10xxxxx010xxxxxxxxxxxxx
21562                                                     st1w.  */
21563                                                  return 1957;
21564                                                }
21565                                              else
21566                                                {
21567                                                  if (((word >> 23) & 0x1) == 0)
21568                                                    {
21569                                                      /* 33222222222211111111110000000000
21570                                                         10987654321098765432109876543210
21571                                                         111001x1011xxxxx010xxxxxxxxxxxxx
21572                                                         st1w.  */
21573                                                      return 1959;
21574                                                    }
21575                                                  else
21576                                                    {
21577                                                      /* 33222222222211111111110000000000
21578                                                         10987654321098765432109876543210
21579                                                         111001x1111xxxxx010xxxxxxxxxxxxx
21580                                                         st1d.  */
21581                                                      return 1936;
21582                                                    }
21583                                                }
21584                                            }
21585                                        }
21586                                    }
21587                                  else
21588                                    {
21589                                      if (((word >> 21) & 0x1) == 0)
21590                                        {
21591                                          if (((word >> 31) & 0x1) == 0)
21592                                            {
21593                                              if (((word >> 4) & 0x1) == 0)
21594                                                {
21595                                                  /* 33222222222211111111110000000000
21596                                                     10987654321098765432109876543210
21597                                                     011001x1xx0xxxxx011xxxxxxxx0xxxx
21598                                                     fcmeq.  */
21599                                                  return 1444;
21600                                                }
21601                                              else
21602                                                {
21603                                                  /* 33222222222211111111110000000000
21604                                                     10987654321098765432109876543210
21605                                                     011001x1xx0xxxxx011xxxxxxxx1xxxx
21606                                                     fcmne.  */
21607                                                  return 1452;
21608                                                }
21609                                            }
21610                                          else
21611                                            {
21612                                              if (((word >> 22) & 0x1) == 0)
21613                                                {
21614                                                  if (((word >> 23) & 0x1) == 0)
21615                                                    {
21616                                                      /* 33222222222211111111110000000000
21617                                                         10987654321098765432109876543210
21618                                                         111001x1000xxxxx011xxxxxxxxxxxxx
21619                                                         stnt1w.  */
21620                                                      return 1995;
21621                                                    }
21622                                                  else
21623                                                    {
21624                                                      /* 33222222222211111111110000000000
21625                                                         10987654321098765432109876543210
21626                                                         111001x1100xxxxx011xxxxxxxxxxxxx
21627                                                         stnt1d.  */
21628                                                      return 1991;
21629                                                    }
21630                                                }
21631                                              else
21632                                                {
21633                                                  if (((word >> 23) & 0x1) == 0)
21634                                                    {
21635                                                      /* 33222222222211111111110000000000
21636                                                         10987654321098765432109876543210
21637                                                         111001x1010xxxxx011xxxxxxxxxxxxx
21638                                                         st3w.  */
21639                                                      return 1979;
21640                                                    }
21641                                                  else
21642                                                    {
21643                                                      /* 33222222222211111111110000000000
21644                                                         10987654321098765432109876543210
21645                                                         111001x1110xxxxx011xxxxxxxxxxxxx
21646                                                         st3d.  */
21647                                                      return 1975;
21648                                                    }
21649                                                }
21650                                            }
21651                                        }
21652                                      else
21653                                        {
21654                                          if (((word >> 31) & 0x1) == 0)
21655                                            {
21656                                              /* 33222222222211111111110000000000
21657                                                 10987654321098765432109876543210
21658                                                 011001x1xx1xxxxx011xxxxxxxxxxxxx
21659                                                 fnmls.  */
21660                                              return 1511;
21661                                            }
21662                                          else
21663                                            {
21664                                              if (((word >> 22) & 0x1) == 0)
21665                                                {
21666                                                  if (((word >> 23) & 0x1) == 0)
21667                                                    {
21668                                                      /* 33222222222211111111110000000000
21669                                                         10987654321098765432109876543210
21670                                                         111001x1001xxxxx011xxxxxxxxxxxxx
21671                                                         st2w.  */
21672                                                      return 1971;
21673                                                    }
21674                                                  else
21675                                                    {
21676                                                      /* 33222222222211111111110000000000
21677                                                         10987654321098765432109876543210
21678                                                         111001x1101xxxxx011xxxxxxxxxxxxx
21679                                                         st2d.  */
21680                                                      return 1967;
21681                                                    }
21682                                                }
21683                                              else
21684                                                {
21685                                                  if (((word >> 23) & 0x1) == 0)
21686                                                    {
21687                                                      /* 33222222222211111111110000000000
21688                                                         10987654321098765432109876543210
21689                                                         111001x1011xxxxx011xxxxxxxxxxxxx
21690                                                         st4w.  */
21691                                                      return 1987;
21692                                                    }
21693                                                  else
21694                                                    {
21695                                                      /* 33222222222211111111110000000000
21696                                                         10987654321098765432109876543210
21697                                                         111001x1111xxxxx011xxxxxxxxxxxxx
21698                                                         st4d.  */
21699                                                      return 1983;
21700                                                    }
21701                                                }
21702                                            }
21703                                        }
21704                                    }
21705                                }
21706                            }
21707                        }
21708                      else
21709                        {
21710                          if (((word >> 21) & 0x1) == 0)
21711                            {
21712                              if (((word >> 30) & 0x1) == 0)
21713                                {
21714                                  if (((word >> 14) & 0x1) == 0)
21715                                    {
21716                                      if (((word >> 13) & 0x1) == 0)
21717                                        {
21718                                          if (((word >> 4) & 0x1) == 0)
21719                                            {
21720                                              /* 33222222222211111111110000000000
21721                                                 10987654321098765432109876543210
21722                                                 x01001x1xx0xxxxx100xxxxxxxx0xxxx
21723                                                 cmpeq.  */
21724                                              return 1373;
21725                                            }
21726                                          else
21727                                            {
21728                                              /* 33222222222211111111110000000000
21729                                                 10987654321098765432109876543210
21730                                                 x01001x1xx0xxxxx100xxxxxxxx1xxxx
21731                                                 cmpne.  */
21732                                              return 1396;
21733                                            }
21734                                        }
21735                                      else
21736                                        {
21737                                          if (((word >> 20) & 0x1) == 0)
21738                                            {
21739                                              if (((word >> 22) & 0x1) == 0)
21740                                                {
21741                                                  if (((word >> 23) & 0x1) == 0)
21742                                                    {
21743                                                      /* 33222222222211111111110000000000
21744                                                         10987654321098765432109876543210
21745                                                         x01001x10000xxxx101xxxxxxxxxxxxx
21746                                                         ld1sh.  */
21747                                                      return 1632;
21748                                                    }
21749                                                  else
21750                                                    {
21751                                                      /* 33222222222211111111110000000000
21752                                                         10987654321098765432109876543210
21753                                                         x01001x11000xxxx101xxxxxxxxxxxxx
21754                                                         ld1sb.  */
21755                                                      return 1619;
21756                                                    }
21757                                                }
21758                                              else
21759                                                {
21760                                                  if (((word >> 23) & 0x1) == 0)
21761                                                    {
21762                                                      /* 33222222222211111111110000000000
21763                                                         10987654321098765432109876543210
21764                                                         x01001x10100xxxx101xxxxxxxxxxxxx
21765                                                         ld1w.  */
21766                                                      return 1651;
21767                                                    }
21768                                                  else
21769                                                    {
21770                                                      /* 33222222222211111111110000000000
21771                                                         10987654321098765432109876543210
21772                                                         x01001x11100xxxx101xxxxxxxxxxxxx
21773                                                         ld1sb.  */
21774                                                      return 1621;
21775                                                    }
21776                                                }
21777                                            }
21778                                          else
21779                                            {
21780                                              if (((word >> 22) & 0x1) == 0)
21781                                                {
21782                                                  if (((word >> 23) & 0x1) == 0)
21783                                                    {
21784                                                      /* 33222222222211111111110000000000
21785                                                         10987654321098765432109876543210
21786                                                         x01001x10001xxxx101xxxxxxxxxxxxx
21787                                                         ldnf1sh.  */
21788                                                      return 1765;
21789                                                    }
21790                                                  else
21791                                                    {
21792                                                      /* 33222222222211111111110000000000
21793                                                         10987654321098765432109876543210
21794                                                         x01001x11001xxxx101xxxxxxxxxxxxx
21795                                                         ldnf1sb.  */
21796                                                      return 1762;
21797                                                    }
21798                                                }
21799                                              else
21800                                                {
21801                                                  if (((word >> 23) & 0x1) == 0)
21802                                                    {
21803                                                      /* 33222222222211111111110000000000
21804                                                         10987654321098765432109876543210
21805                                                         x01001x10101xxxx101xxxxxxxxxxxxx
21806                                                         ldnf1w.  */
21807                                                      return 1768;
21808                                                    }
21809                                                  else
21810                                                    {
21811                                                      /* 33222222222211111111110000000000
21812                                                         10987654321098765432109876543210
21813                                                         x01001x11101xxxx101xxxxxxxxxxxxx
21814                                                         ldnf1sb.  */
21815                                                      return 1764;
21816                                                    }
21817                                                }
21818                                            }
21819                                        }
21820                                    }
21821                                  else
21822                                    {
21823                                      if (((word >> 31) & 0x1) == 0)
21824                                        {
21825                                          if (((word >> 4) & 0x1) == 0)
21826                                            {
21827                                              if (((word >> 20) & 0x1) == 0)
21828                                                {
21829                                                  if (((word >> 22) & 0x1) == 0)
21830                                                    {
21831                                                      /* 33222222222211111111110000000000
21832                                                         10987654321098765432109876543210
21833                                                         001001x1x000xxxx11xxxxxxxxx0xxxx
21834                                                         brkpa.  */
21835                                                      return 1359;
21836                                                    }
21837                                                  else
21838                                                    {
21839                                                      /* 33222222222211111111110000000000
21840                                                         10987654321098765432109876543210
21841                                                         001001x1x100xxxx11xxxxxxxxx0xxxx
21842                                                         brkpas.  */
21843                                                      return 1360;
21844                                                    }
21845                                                }
21846                                              else
21847                                                {
21848                                                  if (((word >> 16) & 0x1) == 0)
21849                                                    {
21850                                                      if (((word >> 19) & 0x1) == 0)
21851                                                        {
21852                                                          /* 33222222222211111111110000000000
21853                                                             10987654321098765432109876543210
21854                                                             001001x1xx010xx011xxxxxxxxx0xxxx
21855                                                             ptest.  */
21856                                                          return 1847;
21857                                                        }
21858                                                      else
21859                                                        {
21860                                                          if (((word >> 10) & 0x1) == 0)
21861                                                            {
21862                                                              if (((word >> 12) & 0x1) == 0)
21863                                                                {
21864                                                                  if (((word >> 13) & 0x1) == 0)
21865                                                                    {
21866                                                                      /* 33222222222211111111110000000000
21867                                                                         10987654321098765432109876543210
21868                                                                         001001x1xx011xx01100x0xxxxx0xxxx
21869                                                                         pfirst.  */
21870                                                                      return 1817;
21871                                                                    }
21872                                                                  else
21873                                                                    {
21874                                                                      /* 33222222222211111111110000000000
21875                                                                         10987654321098765432109876543210
21876                                                                         001001x1xx011xx01110x0xxxxx0xxxx
21877                                                                         ptrue.  */
21878                                                                      return 1848;
21879                                                                    }
21880                                                                }
21881                                                              else
21882                                                                {
21883                                                                  if (((word >> 22) & 0x1) == 0)
21884                                                                    {
21885                                                                      /* 33222222222211111111110000000000
21886                                                                         10987654321098765432109876543210
21887                                                                         001001x1x0011xx011x1x0xxxxx0xxxx
21888                                                                         rdffr.  */
21889                                                                      return 1854;
21890                                                                    }
21891                                                                  else
21892                                                                    {
21893                                                                      /* 33222222222211111111110000000000
21894                                                                         10987654321098765432109876543210
21895                                                                         001001x1x1011xx011x1x0xxxxx0xxxx
21896                                                                         rdffrs.  */
21897                                                                      return 1855;
21898                                                                    }
21899                                                                }
21900                                                            }
21901                                                          else
21902                                                            {
21903                                                              /* 33222222222211111111110000000000
21904                                                                 10987654321098765432109876543210
21905                                                                 001001x1xx011xx011xxx1xxxxx0xxxx
21906                                                                 pfalse.  */
21907                                                              return 1815;
21908                                                            }
21909                                                        }
21910                                                    }
21911                                                  else
21912                                                    {
21913                                                      if (((word >> 10) & 0x1) == 0)
21914                                                        {
21915                                                          if (((word >> 12) & 0x1) == 0)
21916                                                            {
21917                                                              /* 33222222222211111111110000000000
21918                                                                 10987654321098765432109876543210
21919                                                                 001001x1xx01xxx111x0x0xxxxx0xxxx
21920                                                                 ptrues.  */
21921                                                              return 1849;
21922                                                            }
21923                                                          else
21924                                                            {
21925                                                              /* 33222222222211111111110000000000
21926                                                                 10987654321098765432109876543210
21927                                                                 001001x1xx01xxx111x1x0xxxxx0xxxx
21928                                                                 rdffr.  */
21929                                                              return 1853;
21930                                                            }
21931                                                        }
21932                                                      else
21933                                                        {
21934                                                          /* 33222222222211111111110000000000
21935                                                             10987654321098765432109876543210
21936                                                             001001x1xx01xxx111xxx1xxxxx0xxxx
21937                                                             pnext.  */
21938                                                          return 1818;
21939                                                        }
21940                                                    }
21941                                                }
21942                                            }
21943                                          else
21944                                            {
21945                                              if (((word >> 22) & 0x1) == 0)
21946                                                {
21947                                                  /* 33222222222211111111110000000000
21948                                                     10987654321098765432109876543210
21949                                                     001001x1x00xxxxx11xxxxxxxxx1xxxx
21950                                                     brkpb.  */
21951                                                  return 1361;
21952                                                }
21953                                              else
21954                                                {
21955                                                  /* 33222222222211111111110000000000
21956                                                     10987654321098765432109876543210
21957                                                     001001x1x10xxxxx11xxxxxxxxx1xxxx
21958                                                     brkpbs.  */
21959                                                  return 1362;
21960                                                }
21961                                            }
21962                                        }
21963                                      else
21964                                        {
21965                                          if (((word >> 13) & 0x1) == 0)
21966                                            {
21967                                              if (((word >> 22) & 0x1) == 0)
21968                                                {
21969                                                  if (((word >> 23) & 0x1) == 0)
21970                                                    {
21971                                                      /* 33222222222211111111110000000000
21972                                                         10987654321098765432109876543210
21973                                                         101001x1000xxxxx110xxxxxxxxxxxxx
21974                                                         ldnt1w.  */
21975                                                      return 1776;
21976                                                    }
21977                                                  else
21978                                                    {
21979                                                      /* 33222222222211111111110000000000
21980                                                         10987654321098765432109876543210
21981                                                         101001x1100xxxxx110xxxxxxxxxxxxx
21982                                                         ldnt1d.  */
21983                                                      return 1772;
21984                                                    }
21985                                                }
21986                                              else
21987                                                {
21988                                                  if (((word >> 23) & 0x1) == 0)
21989                                                    {
21990                                                      /* 33222222222211111111110000000000
21991                                                         10987654321098765432109876543210
21992                                                         101001x1010xxxxx110xxxxxxxxxxxxx
21993                                                         ld3w.  */
21994                                                      return 1668;
21995                                                    }
21996                                                  else
21997                                                    {
21998                                                      /* 33222222222211111111110000000000
21999                                                         10987654321098765432109876543210
22000                                                         101001x1110xxxxx110xxxxxxxxxxxxx
22001                                                         ld3d.  */
22002                                                      return 1664;
22003                                                    }
22004                                                }
22005                                            }
22006                                          else
22007                                            {
22008                                              if (((word >> 20) & 0x1) == 0)
22009                                                {
22010                                                  if (((word >> 22) & 0x1) == 0)
22011                                                    {
22012                                                      if (((word >> 23) & 0x1) == 0)
22013                                                        {
22014                                                          /* 33222222222211111111110000000000
22015                                                             10987654321098765432109876543210
22016                                                             101001x10000xxxx111xxxxxxxxxxxxx
22017                                                             ldnt1w.  */
22018                                                          return 1777;
22019                                                        }
22020                                                      else
22021                                                        {
22022                                                          /* 33222222222211111111110000000000
22023                                                             10987654321098765432109876543210
22024                                                             101001x11000xxxx111xxxxxxxxxxxxx
22025                                                             ldnt1d.  */
22026                                                          return 1773;
22027                                                        }
22028                                                    }
22029                                                  else
22030                                                    {
22031                                                      if (((word >> 23) & 0x1) == 0)
22032                                                        {
22033                                                          /* 33222222222211111111110000000000
22034                                                             10987654321098765432109876543210
22035                                                             101001x10100xxxx111xxxxxxxxxxxxx
22036                                                             ld3w.  */
22037                                                          return 1669;
22038                                                        }
22039                                                      else
22040                                                        {
22041                                                          /* 33222222222211111111110000000000
22042                                                             10987654321098765432109876543210
22043                                                             101001x11100xxxx111xxxxxxxxxxxxx
22044                                                             ld3d.  */
22045                                                          return 1665;
22046                                                        }
22047                                                    }
22048                                                }
22049                                              else
22050                                                {
22051                                                  if (((word >> 23) & 0x1) == 0)
22052                                                    {
22053                                                      /* 33222222222211111111110000000000
22054                                                         10987654321098765432109876543210
22055                                                         101001x10x01xxxx111xxxxxxxxxxxxx
22056                                                         ld3q.  */
22057                                                      return 3311;
22058                                                    }
22059                                                  else
22060                                                    {
22061                                                      /* 33222222222211111111110000000000
22062                                                         10987654321098765432109876543210
22063                                                         101001x11x01xxxx111xxxxxxxxxxxxx
22064                                                         ld4q.  */
22065                                                      return 3312;
22066                                                    }
22067                                                }
22068                                            }
22069                                        }
22070                                    }
22071                                }
22072                              else
22073                                {
22074                                  if (((word >> 13) & 0x1) == 0)
22075                                    {
22076                                      if (((word >> 31) & 0x1) == 0)
22077                                        {
22078                                          if (((word >> 14) & 0x1) == 0)
22079                                            {
22080                                              if (((word >> 19) & 0x1) == 0)
22081                                                {
22082                                                  if (((word >> 20) & 0x1) == 0)
22083                                                    {
22084                                                      if (((word >> 16) & 0x1) == 0)
22085                                                        {
22086                                                          if (((word >> 17) & 0x1) == 0)
22087                                                            {
22088                                                              if (((word >> 18) & 0x1) == 0)
22089                                                                {
22090                                                                  /* 33222222222211111111110000000000
22091                                                                     10987654321098765432109876543210
22092                                                                     011001x1xx000000100xxxxxxxxxxxxx
22093                                                                     fadd.  */
22094                                                                  return 1435;
22095                                                                }
22096                                                              else
22097                                                                {
22098                                                                  /* 33222222222211111111110000000000
22099                                                                     10987654321098765432109876543210
22100                                                                     011001x1xx000100100xxxxxxxxxxxxx
22101                                                                     fmaxnm.  */
22102                                                                  return 1482;
22103                                                                }
22104                                                            }
22105                                                          else
22106                                                            {
22107                                                              if (((word >> 18) & 0x1) == 0)
22108                                                                {
22109                                                                  /* 33222222222211111111110000000000
22110                                                                     10987654321098765432109876543210
22111                                                                     011001x1xx000010100xxxxxxxxxxxxx
22112                                                                     fmul.  */
22113                                                                  return 1502;
22114                                                                }
22115                                                              else
22116                                                                {
22117                                                                  /* 33222222222211111111110000000000
22118                                                                     10987654321098765432109876543210
22119                                                                     011001x1xx000110100xxxxxxxxxxxxx
22120                                                                     fmax.  */
22121                                                                  return 1480;
22122                                                                }
22123                                                            }
22124                                                        }
22125                                                      else
22126                                                        {
22127                                                          if (((word >> 17) & 0x1) == 0)
22128                                                            {
22129                                                              if (((word >> 18) & 0x1) == 0)
22130                                                                {
22131                                                                  /* 33222222222211111111110000000000
22132                                                                     10987654321098765432109876543210
22133                                                                     011001x1xx000001100xxxxxxxxxxxxx
22134                                                                     fsub.  */
22135                                                                  return 1528;
22136                                                                }
22137                                                              else
22138                                                                {
22139                                                                  /* 33222222222211111111110000000000
22140                                                                     10987654321098765432109876543210
22141                                                                     011001x1xx000101100xxxxxxxxxxxxx
22142                                                                     fminnm.  */
22143                                                                  return 1488;
22144                                                                }
22145                                                            }
22146                                                          else
22147                                                            {
22148                                                              if (((word >> 18) & 0x1) == 0)
22149                                                                {
22150                                                                  /* 33222222222211111111110000000000
22151                                                                     10987654321098765432109876543210
22152                                                                     011001x1xx000011100xxxxxxxxxxxxx
22153                                                                     fsubr.  */
22154                                                                  return 1530;
22155                                                                }
22156                                                              else
22157                                                                {
22158                                                                  /* 33222222222211111111110000000000
22159                                                                     10987654321098765432109876543210
22160                                                                     011001x1xx000111100xxxxxxxxxxxxx
22161                                                                     fmin.  */
22162                                                                  return 1486;
22163                                                                }
22164                                                            }
22165                                                        }
22166                                                    }
22167                                                  else
22168                                                    {
22169                                                      /* 33222222222211111111110000000000
22170                                                         10987654321098765432109876543210
22171                                                         011001x1xx010xxx100xxxxxxxxxxxxx
22172                                                         ftmad.  */
22173                                                      return 1532;
22174                                                    }
22175                                                }
22176                                              else
22177                                                {
22178                                                  if (((word >> 16) & 0x1) == 0)
22179                                                    {
22180                                                      if (((word >> 17) & 0x1) == 0)
22181                                                        {
22182                                                          if (((word >> 18) & 0x1) == 0)
22183                                                            {
22184                                                              if (((word >> 20) & 0x1) == 0)
22185                                                                {
22186                                                                  /* 33222222222211111111110000000000
22187                                                                     10987654321098765432109876543210
22188                                                                     011001x1xx001000100xxxxxxxxxxxxx
22189                                                                     fabd.  */
22190                                                                  return 1430;
22191                                                                }
22192                                                              else
22193                                                                {
22194                                                                  /* 33222222222211111111110000000000
22195                                                                     10987654321098765432109876543210
22196                                                                     011001x1xx011000100xxxxxxxxxxxxx
22197                                                                     fadd.  */
22198                                                                  return 1436;
22199                                                                }
22200                                                            }
22201                                                          else
22202                                                            {
22203                                                              if (((word >> 20) & 0x1) == 0)
22204                                                                {
22205                                                                  /* 33222222222211111111110000000000
22206                                                                     10987654321098765432109876543210
22207                                                                     011001x1xx001100100xxxxxxxxxxxxx
22208                                                                     fdivr.  */
22209                                                                  return 1476;
22210                                                                }
22211                                                              else
22212                                                                {
22213                                                                  /* 33222222222211111111110000000000
22214                                                                     10987654321098765432109876543210
22215                                                                     011001x1xx011100100xxxxxxxxxxxxx
22216                                                                     fmaxnm.  */
22217                                                                  return 1483;
22218                                                                }
22219                                                            }
22220                                                        }
22221                                                      else
22222                                                        {
22223                                                          if (((word >> 18) & 0x1) == 0)
22224                                                            {
22225                                                              if (((word >> 20) & 0x1) == 0)
22226                                                                {
22227                                                                  /* 33222222222211111111110000000000
22228                                                                     10987654321098765432109876543210
22229                                                                     011001x1xx001010100xxxxxxxxxxxxx
22230                                                                     fmulx.  */
22231                                                                  return 1507;
22232                                                                }
22233                                                              else
22234                                                                {
22235                                                                  /* 33222222222211111111110000000000
22236                                                                     10987654321098765432109876543210
22237                                                                     011001x1xx011010100xxxxxxxxxxxxx
22238                                                                     fmul.  */
22239                                                                  return 1503;
22240                                                                }
22241                                                            }
22242                                                          else
22243                                                            {
22244                                                              /* 33222222222211111111110000000000
22245                                                                 10987654321098765432109876543210
22246                                                                 011001x1xx0x1110100xxxxxxxxxxxxx
22247                                                                 fmax.  */
22248                                                              return 1481;
22249                                                            }
22250                                                        }
22251                                                    }
22252                                                  else
22253                                                    {
22254                                                      if (((word >> 17) & 0x1) == 0)
22255                                                        {
22256                                                          if (((word >> 18) & 0x1) == 0)
22257                                                            {
22258                                                              if (((word >> 20) & 0x1) == 0)
22259                                                                {
22260                                                                  /* 33222222222211111111110000000000
22261                                                                     10987654321098765432109876543210
22262                                                                     011001x1xx001001100xxxxxxxxxxxxx
22263                                                                     fscale.  */
22264                                                                  return 1525;
22265                                                                }
22266                                                              else
22267                                                                {
22268                                                                  /* 33222222222211111111110000000000
22269                                                                     10987654321098765432109876543210
22270                                                                     011001x1xx011001100xxxxxxxxxxxxx
22271                                                                     fsub.  */
22272                                                                  return 1529;
22273                                                                }
22274                                                            }
22275                                                          else
22276                                                            {
22277                                                              if (((word >> 20) & 0x1) == 0)
22278                                                                {
22279                                                                  /* 33222222222211111111110000000000
22280                                                                     10987654321098765432109876543210
22281                                                                     011001x1xx001101100xxxxxxxxxxxxx
22282                                                                     fdiv.  */
22283                                                                  return 1475;
22284                                                                }
22285                                                              else
22286                                                                {
22287                                                                  /* 33222222222211111111110000000000
22288                                                                     10987654321098765432109876543210
22289                                                                     011001x1xx011101100xxxxxxxxxxxxx
22290                                                                     fminnm.  */
22291                                                                  return 1489;
22292                                                                }
22293                                                            }
22294                                                        }
22295                                                      else
22296                                                        {
22297                                                          if (((word >> 18) & 0x1) == 0)
22298                                                            {
22299                                                              /* 33222222222211111111110000000000
22300                                                                 10987654321098765432109876543210
22301                                                                 011001x1xx0x1011100xxxxxxxxxxxxx
22302                                                                 fsubr.  */
22303                                                              return 1531;
22304                                                            }
22305                                                          else
22306                                                            {
22307                                                              /* 33222222222211111111110000000000
22308                                                                 10987654321098765432109876543210
22309                                                                 011001x1xx0x1111100xxxxxxxxxxxxx
22310                                                                 fmin.  */
22311                                                              return 1487;
22312                                                            }
22313                                                        }
22314                                                    }
22315                                                }
22316                                            }
22317                                          else
22318                                            {
22319                                              if (((word >> 4) & 0x1) == 0)
22320                                                {
22321                                                  /* 33222222222211111111110000000000
22322                                                     10987654321098765432109876543210
22323                                                     011001x1xx0xxxxx110xxxxxxxx0xxxx
22324                                                     fcmuo.  */
22325                                                  return 1453;
22326                                                }
22327                                              else
22328                                                {
22329                                                  /* 33222222222211111111110000000000
22330                                                     10987654321098765432109876543210
22331                                                     011001x1xx0xxxxx110xxxxxxxx1xxxx
22332                                                     facge.  */
22333                                                  return 1432;
22334                                                }
22335                                            }
22336                                        }
22337                                      else
22338                                        {
22339                                          if (((word >> 22) & 0x1) == 0)
22340                                            {
22341                                              if (((word >> 23) & 0x1) == 0)
22342                                                {
22343                                                  /* 33222222222211111111110000000000
22344                                                     10987654321098765432109876543210
22345                                                     111001x1000xxxxx1x0xxxxxxxxxxxxx
22346                                                     st1w.  */
22347                                                  return 1953;
22348                                                }
22349                                              else
22350                                                {
22351                                                  /* 33222222222211111111110000000000
22352                                                     10987654321098765432109876543210
22353                                                     111001x1100xxxxx1x0xxxxxxxxxxxxx
22354                                                     st1d.  */
22355                                                  return 1932;
22356                                                }
22357                                            }
22358                                          else
22359                                            {
22360                                              /* 33222222222211111111110000000000
22361                                                 10987654321098765432109876543210
22362                                                 111001x1x10xxxxx1x0xxxxxxxxxxxxx
22363                                                 st1w.  */
22364                                              return 1958;
22365                                            }
22366                                        }
22367                                    }
22368                                  else
22369                                    {
22370                                      if (((word >> 14) & 0x1) == 0)
22371                                        {
22372                                          if (((word >> 31) & 0x1) == 0)
22373                                            {
22374                                              if (((word >> 16) & 0x1) == 0)
22375                                                {
22376                                                  if (((word >> 19) & 0x1) == 0)
22377                                                    {
22378                                                      if (((word >> 17) & 0x1) == 0)
22379                                                        {
22380                                                          if (((word >> 18) & 0x1) == 0)
22381                                                            {
22382                                                              if (((word >> 20) & 0x1) == 0)
22383                                                                {
22384                                                                  /* 33222222222211111111110000000000
22385                                                                     10987654321098765432109876543210
22386                                                                     011001x1xx000000101xxxxxxxxxxxxx
22387                                                                     frintn.  */
22388                                                                  return 1519;
22389                                                                }
22390                                                              else
22391                                                                {
22392                                                                  /* 33222222222211111111110000000000
22393                                                                     10987654321098765432109876543210
22394                                                                     011001x1xx010000101xxxxxxxxxxxxx
22395                                                                     scvtf.  */
22396                                                                  return 1867;
22397                                                                }
22398                                                            }
22399                                                          else
22400                                                            {
22401                                                              if (((word >> 20) & 0x1) == 0)
22402                                                                {
22403                                                                  /* 33222222222211111111110000000000
22404                                                                     10987654321098765432109876543210
22405                                                                     011001x1xx000100101xxxxxxxxxxxxx
22406                                                                     frinta.  */
22407                                                                  return 1516;
22408                                                                }
22409                                                              else
22410                                                                {
22411                                                                  if (((word >> 22) & 0x1) == 0)
22412                                                                    {
22413                                                                      /* 33222222222211111111110000000000
22414                                                                         10987654321098765432109876543210
22415                                                                         011001x1x0010100101xxxxxxxxxxxxx
22416                                                                         scvtf.  */
22417                                                                      return 1866;
22418                                                                    }
22419                                                                  else
22420                                                                    {
22421                                                                      if (((word >> 23) & 0x1) == 0)
22422                                                                        {
22423                                                                          /* 33222222222211111111110000000000
22424                                                                             10987654321098765432109876543210
22425                                                                             011001x101010100101xxxxxxxxxxxxx
22426                                                                             scvtf.  */
22427                                                                          return 1865;
22428                                                                        }
22429                                                                      else
22430                                                                        {
22431                                                                          /* 33222222222211111111110000000000
22432                                                                             10987654321098765432109876543210
22433                                                                             011001x111010100101xxxxxxxxxxxxx
22434                                                                             scvtf.  */
22435                                                                          return 1869;
22436                                                                        }
22437                                                                    }
22438                                                                }
22439                                                            }
22440                                                        }
22441                                                      else
22442                                                        {
22443                                                          if (((word >> 18) & 0x1) == 0)
22444                                                            {
22445                                                              if (((word >> 20) & 0x1) == 0)
22446                                                                {
22447                                                                  /* 33222222222211111111110000000000
22448                                                                     10987654321098765432109876543210
22449                                                                     011001x1xx000010101xxxxxxxxxxxxx
22450                                                                     frintm.  */
22451                                                                  return 1518;
22452                                                                }
22453                                                              else
22454                                                                {
22455                                                                  /* 33222222222211111111110000000000
22456                                                                     10987654321098765432109876543210
22457                                                                     011001x1xx010010101xxxxxxxxxxxxx
22458                                                                     scvtf.  */
22459                                                                  return 1864;
22460                                                                }
22461                                                            }
22462                                                          else
22463                                                            {
22464                                                              if (((word >> 20) & 0x1) == 0)
22465                                                                {
22466                                                                  /* 33222222222211111111110000000000
22467                                                                     10987654321098765432109876543210
22468                                                                     011001x1xx000110101xxxxxxxxxxxxx
22469                                                                     frintx.  */
22470                                                                  return 1521;
22471                                                                }
22472                                                              else
22473                                                                {
22474                                                                  if (((word >> 23) & 0x1) == 0)
22475                                                                    {
22476                                                                      /* 33222222222211111111110000000000
22477                                                                         10987654321098765432109876543210
22478                                                                         011001x10x010110101xxxxxxxxxxxxx
22479                                                                         scvtf.  */
22480                                                                      return 1868;
22481                                                                    }
22482                                                                  else
22483                                                                    {
22484                                                                      /* 33222222222211111111110000000000
22485                                                                         10987654321098765432109876543210
22486                                                                         011001x11x010110101xxxxxxxxxxxxx
22487                                                                         scvtf.  */
22488                                                                      return 1870;
22489                                                                    }
22490                                                                }
22491                                                            }
22492                                                        }
22493                                                    }
22494                                                  else
22495                                                    {
22496                                                      if (((word >> 20) & 0x1) == 0)
22497                                                        {
22498                                                          if (((word >> 17) & 0x1) == 0)
22499                                                            {
22500                                                              if (((word >> 18) & 0x1) == 0)
22501                                                                {
22502                                                                  if (((word >> 22) & 0x1) == 0)
22503                                                                    {
22504                                                                      /* 33222222222211111111110000000000
22505                                                                         10987654321098765432109876543210
22506                                                                         011001x1x0001000101xxxxxxxxxxxxx
22507                                                                         fcvt.  */
22508                                                                      return 1455;
22509                                                                    }
22510                                                                  else
22511                                                                    {
22512                                                                      /* 33222222222211111111110000000000
22513                                                                         10987654321098765432109876543210
22514                                                                         011001x1x1001000101xxxxxxxxxxxxx
22515                                                                         fcvt.  */
22516                                                                      return 1457;
22517                                                                    }
22518                                                                }
22519                                                              else
22520                                                                {
22521                                                                  /* 33222222222211111111110000000000
22522                                                                     10987654321098765432109876543210
22523                                                                     011001x1xx001100101xxxxxxxxxxxxx
22524                                                                     frecpx.  */
22525                                                                  return 1515;
22526                                                                }
22527                                                            }
22528                                                          else
22529                                                            {
22530                                                              if (((word >> 22) & 0x1) == 0)
22531                                                                {
22532                                                                  if (((word >> 23) & 0x1) == 0)
22533                                                                    {
22534                                                                      /* 33222222222211111111110000000000
22535                                                                         10987654321098765432109876543210
22536                                                                         011001x100001x10101xxxxxxxxxxxxx
22537                                                                         fcvtx.  */
22538                                                                      return 2128;
22539                                                                    }
22540                                                                  else
22541                                                                    {
22542                                                                      /* 33222222222211111111110000000000
22543                                                                         10987654321098765432109876543210
22544                                                                         011001x110001x10101xxxxxxxxxxxxx
22545                                                                         bfcvt.  */
22546                                                                      return 3057;
22547                                                                    }
22548                                                                }
22549                                                              else
22550                                                                {
22551                                                                  /* 33222222222211111111110000000000
22552                                                                     10987654321098765432109876543210
22553                                                                     011001x1x1001x10101xxxxxxxxxxxxx
22554                                                                     fcvt.  */
22555                                                                  return 1459;
22556                                                                }
22557                                                            }
22558                                                        }
22559                                                      else
22560                                                        {
22561                                                          if (((word >> 22) & 0x1) == 0)
22562                                                            {
22563                                                              if (((word >> 23) & 0x1) == 0)
22564                                                                {
22565                                                                  /* 33222222222211111111110000000000
22566                                                                     10987654321098765432109876543210
22567                                                                     011001x100011xx0101xxxxxxxxxxxxx
22568                                                                     flogb.  */
22569                                                                  return 2130;
22570                                                                }
22571                                                              else
22572                                                                {
22573                                                                  /* 33222222222211111111110000000000
22574                                                                     10987654321098765432109876543210
22575                                                                     011001x110011xx0101xxxxxxxxxxxxx
22576                                                                     fcvtzs.  */
22577                                                                  return 1464;
22578                                                                }
22579                                                            }
22580                                                          else
22581                                                            {
22582                                                              if (((word >> 17) & 0x1) == 0)
22583                                                                {
22584                                                                  if (((word >> 18) & 0x1) == 0)
22585                                                                    {
22586                                                                      /* 33222222222211111111110000000000
22587                                                                         10987654321098765432109876543210
22588                                                                         011001x1x1011000101xxxxxxxxxxxxx
22589                                                                         fcvtzs.  */
22590                                                                      return 1465;
22591                                                                    }
22592                                                                  else
22593                                                                    {
22594                                                                      if (((word >> 23) & 0x1) == 0)
22595                                                                        {
22596                                                                          /* 33222222222211111111110000000000
22597                                                                             10987654321098765432109876543210
22598                                                                             011001x101011100101xxxxxxxxxxxxx
22599                                                                             fcvtzs.  */
22600                                                                          return 1462;
22601                                                                        }
22602                                                                      else
22603                                                                        {
22604                                                                          /* 33222222222211111111110000000000
22605                                                                             10987654321098765432109876543210
22606                                                                             011001x111011100101xxxxxxxxxxxxx
22607                                                                             fcvtzs.  */
22608                                                                          return 1466;
22609                                                                        }
22610                                                                    }
22611                                                                }
22612                                                              else
22613                                                                {
22614                                                                  if (((word >> 18) & 0x1) == 0)
22615                                                                    {
22616                                                                      /* 33222222222211111111110000000000
22617                                                                         10987654321098765432109876543210
22618                                                                         011001x1x1011010101xxxxxxxxxxxxx
22619                                                                         fcvtzs.  */
22620                                                                      return 1461;
22621                                                                    }
22622                                                                  else
22623                                                                    {
22624                                                                      if (((word >> 23) & 0x1) == 0)
22625                                                                        {
22626                                                                          /* 33222222222211111111110000000000
22627                                                                             10987654321098765432109876543210
22628                                                                             011001x101011110101xxxxxxxxxxxxx
22629                                                                             fcvtzs.  */
22630                                                                          return 1463;
22631                                                                        }
22632                                                                      else
22633                                                                        {
22634                                                                          /* 33222222222211111111110000000000
22635                                                                             10987654321098765432109876543210
22636                                                                             011001x111011110101xxxxxxxxxxxxx
22637                                                                             fcvtzs.  */
22638                                                                          return 1467;
22639                                                                        }
22640                                                                    }
22641                                                                }
22642                                                            }
22643                                                        }
22644                                                    }
22645                                                }
22646                                              else
22647                                                {
22648                                                  if (((word >> 17) & 0x1) == 0)
22649                                                    {
22650                                                      if (((word >> 18) & 0x1) == 0)
22651                                                        {
22652                                                          if (((word >> 19) & 0x1) == 0)
22653                                                            {
22654                                                              if (((word >> 20) & 0x1) == 0)
22655                                                                {
22656                                                                  /* 33222222222211111111110000000000
22657                                                                     10987654321098765432109876543210
22658                                                                     011001x1xx000001101xxxxxxxxxxxxx
22659                                                                     frintp.  */
22660                                                                  return 1520;
22661                                                                }
22662                                                              else
22663                                                                {
22664                                                                  /* 33222222222211111111110000000000
22665                                                                     10987654321098765432109876543210
22666                                                                     011001x1xx010001101xxxxxxxxxxxxx
22667                                                                     ucvtf.  */
22668                                                                  return 2020;
22669                                                                }
22670                                                            }
22671                                                          else
22672                                                            {
22673                                                              if (((word >> 20) & 0x1) == 0)
22674                                                                {
22675                                                                  if (((word >> 22) & 0x1) == 0)
22676                                                                    {
22677                                                                      /* 33222222222211111111110000000000
22678                                                                         10987654321098765432109876543210
22679                                                                         011001x1x0001001101xxxxxxxxxxxxx
22680                                                                         fcvt.  */
22681                                                                      return 1456;
22682                                                                    }
22683                                                                  else
22684                                                                    {
22685                                                                      /* 33222222222211111111110000000000
22686                                                                         10987654321098765432109876543210
22687                                                                         011001x1x1001001101xxxxxxxxxxxxx
22688                                                                         fcvt.  */
22689                                                                      return 1458;
22690                                                                    }
22691                                                                }
22692                                                              else
22693                                                                {
22694                                                                  /* 33222222222211111111110000000000
22695                                                                     10987654321098765432109876543210
22696                                                                     011001x1xx011001101xxxxxxxxxxxxx
22697                                                                     fcvtzu.  */
22698                                                                  return 1472;
22699                                                                }
22700                                                            }
22701                                                        }
22702                                                      else
22703                                                        {
22704                                                          if (((word >> 19) & 0x1) == 0)
22705                                                            {
22706                                                              if (((word >> 22) & 0x1) == 0)
22707                                                                {
22708                                                                  /* 33222222222211111111110000000000
22709                                                                     10987654321098765432109876543210
22710                                                                     011001x1x00x0101101xxxxxxxxxxxxx
22711                                                                     ucvtf.  */
22712                                                                  return 2019;
22713                                                                }
22714                                                              else
22715                                                                {
22716                                                                  if (((word >> 23) & 0x1) == 0)
22717                                                                    {
22718                                                                      /* 33222222222211111111110000000000
22719                                                                         10987654321098765432109876543210
22720                                                                         011001x1010x0101101xxxxxxxxxxxxx
22721                                                                         ucvtf.  */
22722                                                                      return 2018;
22723                                                                    }
22724                                                                  else
22725                                                                    {
22726                                                                      /* 33222222222211111111110000000000
22727                                                                         10987654321098765432109876543210
22728                                                                         011001x1110x0101101xxxxxxxxxxxxx
22729                                                                         ucvtf.  */
22730                                                                      return 2022;
22731                                                                    }
22732                                                                }
22733                                                            }
22734                                                          else
22735                                                            {
22736                                                              if (((word >> 20) & 0x1) == 0)
22737                                                                {
22738                                                                  /* 33222222222211111111110000000000
22739                                                                     10987654321098765432109876543210
22740                                                                     011001x1xx001101101xxxxxxxxxxxxx
22741                                                                     fsqrt.  */
22742                                                                  return 1526;
22743                                                                }
22744                                                              else
22745                                                                {
22746                                                                  if (((word >> 22) & 0x1) == 0)
22747                                                                    {
22748                                                                      /* 33222222222211111111110000000000
22749                                                                         10987654321098765432109876543210
22750                                                                         011001x1x0011101101xxxxxxxxxxxxx
22751                                                                         fcvtzu.  */
22752                                                                      return 1471;
22753                                                                    }
22754                                                                  else
22755                                                                    {
22756                                                                      if (((word >> 23) & 0x1) == 0)
22757                                                                        {
22758                                                                          /* 33222222222211111111110000000000
22759                                                                             10987654321098765432109876543210
22760                                                                             011001x101011101101xxxxxxxxxxxxx
22761                                                                             fcvtzu.  */
22762                                                                          return 1469;
22763                                                                        }
22764                                                                      else
22765                                                                        {
22766                                                                          /* 33222222222211111111110000000000
22767                                                                             10987654321098765432109876543210
22768                                                                             011001x111011101101xxxxxxxxxxxxx
22769                                                                             fcvtzu.  */
22770                                                                          return 1473;
22771                                                                        }
22772                                                                    }
22773                                                                }
22774                                                            }
22775                                                        }
22776                                                    }
22777                                                  else
22778                                                    {
22779                                                      if (((word >> 18) & 0x1) == 0)
22780                                                        {
22781                                                          if (((word >> 19) & 0x1) == 0)
22782                                                            {
22783                                                              if (((word >> 20) & 0x1) == 0)
22784                                                                {
22785                                                                  /* 33222222222211111111110000000000
22786                                                                     10987654321098765432109876543210
22787                                                                     011001x1xx000011101xxxxxxxxxxxxx
22788                                                                     frintz.  */
22789                                                                  return 1522;
22790                                                                }
22791                                                              else
22792                                                                {
22793                                                                  /* 33222222222211111111110000000000
22794                                                                     10987654321098765432109876543210
22795                                                                     011001x1xx010011101xxxxxxxxxxxxx
22796                                                                     ucvtf.  */
22797                                                                  return 2017;
22798                                                                }
22799                                                            }
22800                                                          else
22801                                                            {
22802                                                              if (((word >> 20) & 0x1) == 0)
22803                                                                {
22804                                                                  /* 33222222222211111111110000000000
22805                                                                     10987654321098765432109876543210
22806                                                                     011001x1xx001011101xxxxxxxxxxxxx
22807                                                                     fcvt.  */
22808                                                                  return 1460;
22809                                                                }
22810                                                              else
22811                                                                {
22812                                                                  /* 33222222222211111111110000000000
22813                                                                     10987654321098765432109876543210
22814                                                                     011001x1xx011011101xxxxxxxxxxxxx
22815                                                                     fcvtzu.  */
22816                                                                  return 1468;
22817                                                                }
22818                                                            }
22819                                                        }
22820                                                      else
22821                                                        {
22822                                                          if (((word >> 19) & 0x1) == 0)
22823                                                            {
22824                                                              if (((word >> 20) & 0x1) == 0)
22825                                                                {
22826                                                                  /* 33222222222211111111110000000000
22827                                                                     10987654321098765432109876543210
22828                                                                     011001x1xx000111101xxxxxxxxxxxxx
22829                                                                     frinti.  */
22830                                                                  return 1517;
22831                                                                }
22832                                                              else
22833                                                                {
22834                                                                  if (((word >> 23) & 0x1) == 0)
22835                                                                    {
22836                                                                      /* 33222222222211111111110000000000
22837                                                                         10987654321098765432109876543210
22838                                                                         011001x10x010111101xxxxxxxxxxxxx
22839                                                                         ucvtf.  */
22840                                                                      return 2021;
22841                                                                    }
22842                                                                  else
22843                                                                    {
22844                                                                      /* 33222222222211111111110000000000
22845                                                                         10987654321098765432109876543210
22846                                                                         011001x11x010111101xxxxxxxxxxxxx
22847                                                                         ucvtf.  */
22848                                                                      return 2023;
22849                                                                    }
22850                                                                }
22851                                                            }
22852                                                          else
22853                                                            {
22854                                                              if (((word >> 23) & 0x1) == 0)
22855                                                                {
22856                                                                  /* 33222222222211111111110000000000
22857                                                                     10987654321098765432109876543210
22858                                                                     011001x10x0x1111101xxxxxxxxxxxxx
22859                                                                     fcvtzu.  */
22860                                                                  return 1470;
22861                                                                }
22862                                                              else
22863                                                                {
22864                                                                  /* 33222222222211111111110000000000
22865                                                                     10987654321098765432109876543210
22866                                                                     011001x11x0x1111101xxxxxxxxxxxxx
22867                                                                     fcvtzu.  */
22868                                                                  return 1474;
22869                                                                }
22870                                                            }
22871                                                        }
22872                                                    }
22873                                                }
22874                                            }
22875                                          else
22876                                            {
22877                                              if (((word >> 22) & 0x1) == 0)
22878                                                {
22879                                                  if (((word >> 23) & 0x1) == 0)
22880                                                    {
22881                                                      /* 33222222222211111111110000000000
22882                                                         10987654321098765432109876543210
22883                                                         111001x1000xxxxx101xxxxxxxxxxxxx
22884                                                         st1w.  */
22885                                                      return 1954;
22886                                                    }
22887                                                  else
22888                                                    {
22889                                                      /* 33222222222211111111110000000000
22890                                                         10987654321098765432109876543210
22891                                                         111001x1100xxxxx101xxxxxxxxxxxxx
22892                                                         st1d.  */
22893                                                      return 1933;
22894                                                    }
22895                                                }
22896                                              else
22897                                                {
22898                                                  if (((word >> 23) & 0x1) == 0)
22899                                                    {
22900                                                      /* 33222222222211111111110000000000
22901                                                         10987654321098765432109876543210
22902                                                         111001x1010xxxxx101xxxxxxxxxxxxx
22903                                                         st1w.  */
22904                                                      return 1961;
22905                                                    }
22906                                                  else
22907                                                    {
22908                                                      /* 33222222222211111111110000000000
22909                                                         10987654321098765432109876543210
22910                                                         111001x1110xxxxx101xxxxxxxxxxxxx
22911                                                         st1d.  */
22912                                                      return 1937;
22913                                                    }
22914                                                }
22915                                            }
22916                                        }
22917                                      else
22918                                        {
22919                                          if (((word >> 31) & 0x1) == 0)
22920                                            {
22921                                              /* 33222222222211111111110000000000
22922                                                 10987654321098765432109876543210
22923                                                 011001x1xx0xxxxx111xxxxxxxxxxxxx
22924                                                 facgt.  */
22925                                              return 1433;
22926                                            }
22927                                          else
22928                                            {
22929                                              if (((word >> 20) & 0x1) == 0)
22930                                                {
22931                                                  /* 33222222222211111111110000000000
22932                                                     10987654321098765432109876543210
22933                                                     111001x1xx00xxxx111xxxxxxxxxxxxx
22934                                                     st1w.  */
22935                                                  return 1962;
22936                                                }
22937                                              else
22938                                                {
22939                                                  if (((word >> 22) & 0x1) == 0)
22940                                                    {
22941                                                      if (((word >> 23) & 0x1) == 0)
22942                                                        {
22943                                                          /* 33222222222211111111110000000000
22944                                                             10987654321098765432109876543210
22945                                                             111001x10001xxxx111xxxxxxxxxxxxx
22946                                                             stnt1w.  */
22947                                                          return 1996;
22948                                                        }
22949                                                      else
22950                                                        {
22951                                                          /* 33222222222211111111110000000000
22952                                                             10987654321098765432109876543210
22953                                                             111001x11001xxxx111xxxxxxxxxxxxx
22954                                                             stnt1d.  */
22955                                                          return 1992;
22956                                                        }
22957                                                    }
22958                                                  else
22959                                                    {
22960                                                      if (((word >> 23) & 0x1) == 0)
22961                                                        {
22962                                                          /* 33222222222211111111110000000000
22963                                                             10987654321098765432109876543210
22964                                                             111001x10101xxxx111xxxxxxxxxxxxx
22965                                                             st3w.  */
22966                                                          return 1980;
22967                                                        }
22968                                                      else
22969                                                        {
22970                                                          /* 33222222222211111111110000000000
22971                                                             10987654321098765432109876543210
22972                                                             111001x11101xxxx111xxxxxxxxxxxxx
22973                                                             st3d.  */
22974                                                          return 1976;
22975                                                        }
22976                                                    }
22977                                                }
22978                                            }
22979                                        }
22980                                    }
22981                                }
22982                            }
22983                          else
22984                            {
22985                              if (((word >> 30) & 0x1) == 0)
22986                                {
22987                                  if (((word >> 14) & 0x1) == 0)
22988                                    {
22989                                      if (((word >> 31) & 0x1) == 0)
22990                                        {
22991                                          if (((word >> 9) & 0x1) == 0)
22992                                            {
22993                                              if (((word >> 16) & 0x1) == 0)
22994                                                {
22995                                                  if (((word >> 17) & 0x1) == 0)
22996                                                    {
22997                                                      if (((word >> 18) & 0x1) == 0)
22998                                                        {
22999                                                          if (((word >> 19) & 0x1) == 0)
23000                                                            {
23001                                                              /* 33222222222211111111110000000000
23002                                                                 10987654321098765432109876543210
23003                                                                 001001x1xx1x000010xxxx0xxxxxxxxx
23004                                                                 cntp.  */
23005                                                              return 1402;
23006                                                            }
23007                                                          else
23008                                                            {
23009                                                              if (((word >> 10) & 0x1) == 0)
23010                                                                {
23011                                                                  if (((word >> 11) & 0x1) == 0)
23012                                                                    {
23013                                                                      if (((word >> 12) & 0x1) == 0)
23014                                                                        {
23015                                                                          /* 33222222222211111111110000000000
23016                                                                             10987654321098765432109876543210
23017                                                                             001001x1xx1x100010x0000xxxxxxxxx
23018                                                                             sqincp.  */
23019                                                                          return 1911;
23020                                                                        }
23021                                                                      else
23022                                                                        {
23023                                                                          /* 33222222222211111111110000000000
23024                                                                             10987654321098765432109876543210
23025                                                                             001001x1xx1x100010x1000xxxxxxxxx
23026                                                                             wrffr.  */
23027                                                                          return 2085;
23028                                                                        }
23029                                                                    }
23030                                                                  else
23031                                                                    {
23032                                                                      /* 33222222222211111111110000000000
23033                                                                         10987654321098765432109876543210
23034                                                                         001001x1xx1x100010xx100xxxxxxxxx
23035                                                                         sqincp.  */
23036                                                                      return 1913;
23037                                                                    }
23038                                                                }
23039                                                              else
23040                                                                {
23041                                                                  /* 33222222222211111111110000000000
23042                                                                     10987654321098765432109876543210
23043                                                                     001001x1xx1x100010xxx10xxxxxxxxx
23044                                                                     sqincp.  */
23045                                                                  return 1912;
23046                                                                }
23047                                                            }
23048                                                        }
23049                                                      else
23050                                                        {
23051                                                          if (((word >> 11) & 0x1) == 0)
23052                                                            {
23053                                                              if (((word >> 12) & 0x1) == 0)
23054                                                                {
23055                                                                  /* 33222222222211111111110000000000
23056                                                                     10987654321098765432109876543210
23057                                                                     001001x1xx1xx10010x00x0xxxxxxxxx
23058                                                                     incp.  */
23059                                                                  return 1540;
23060                                                                }
23061                                                              else
23062                                                                {
23063                                                                  /* 33222222222211111111110000000000
23064                                                                     10987654321098765432109876543210
23065                                                                     001001x1xx1xx10010x10x0xxxxxxxxx
23066                                                                     setffr.  */
23067                                                                  return 1878;
23068                                                                }
23069                                                            }
23070                                                          else
23071                                                            {
23072                                                              /* 33222222222211111111110000000000
23073                                                                 10987654321098765432109876543210
23074                                                                 001001x1xx1xx10010xx1x0xxxxxxxxx
23075                                                                 incp.  */
23076                                                              return 1541;
23077                                                            }
23078                                                        }
23079                                                    }
23080                                                  else
23081                                                    {
23082                                                      if (((word >> 10) & 0x1) == 0)
23083                                                        {
23084                                                          if (((word >> 11) & 0x1) == 0)
23085                                                            {
23086                                                              /* 33222222222211111111110000000000
23087                                                                 10987654321098765432109876543210
23088                                                                 001001x1xx1xxx1010xx000xxxxxxxxx
23089                                                                 sqdecp.  */
23090                                                              return 1897;
23091                                                            }
23092                                                          else
23093                                                            {
23094                                                              /* 33222222222211111111110000000000
23095                                                                 10987654321098765432109876543210
23096                                                                 001001x1xx1xxx1010xx100xxxxxxxxx
23097                                                                 sqdecp.  */
23098                                                              return 1899;
23099                                                            }
23100                                                        }
23101                                                      else
23102                                                        {
23103                                                          /* 33222222222211111111110000000000
23104                                                             10987654321098765432109876543210
23105                                                             001001x1xx1xxx1010xxx10xxxxxxxxx
23106                                                             sqdecp.  */
23107                                                          return 1898;
23108                                                        }
23109                                                    }
23110                                                }
23111                                              else
23112                                                {
23113                                                  if (((word >> 10) & 0x1) == 0)
23114                                                    {
23115                                                      if (((word >> 11) & 0x1) == 0)
23116                                                        {
23117                                                          if (((word >> 17) & 0x1) == 0)
23118                                                            {
23119                                                              if (((word >> 18) & 0x1) == 0)
23120                                                                {
23121                                                                  /* 33222222222211111111110000000000
23122                                                                     10987654321098765432109876543210
23123                                                                     001001x1xx1xx00110xx000xxxxxxxxx
23124                                                                     uqincp.  */
23125                                                                  return 2060;
23126                                                                }
23127                                                              else
23128                                                                {
23129                                                                  /* 33222222222211111111110000000000
23130                                                                     10987654321098765432109876543210
23131                                                                     001001x1xx1xx10110xx000xxxxxxxxx
23132                                                                     decp.  */
23133                                                                  return 1415;
23134                                                                }
23135                                                            }
23136                                                          else
23137                                                            {
23138                                                              /* 33222222222211111111110000000000
23139                                                                 10987654321098765432109876543210
23140                                                                 001001x1xx1xxx1110xx000xxxxxxxxx
23141                                                                 uqdecp.  */
23142                                                              return 2046;
23143                                                            }
23144                                                        }
23145                                                      else
23146                                                        {
23147                                                          if (((word >> 17) & 0x1) == 0)
23148                                                            {
23149                                                              if (((word >> 18) & 0x1) == 0)
23150                                                                {
23151                                                                  /* 33222222222211111111110000000000
23152                                                                     10987654321098765432109876543210
23153                                                                     001001x1xx1xx00110xx100xxxxxxxxx
23154                                                                     uqincp.  */
23155                                                                  return 2061;
23156                                                                }
23157                                                              else
23158                                                                {
23159                                                                  /* 33222222222211111111110000000000
23160                                                                     10987654321098765432109876543210
23161                                                                     001001x1xx1xx10110xx100xxxxxxxxx
23162                                                                     decp.  */
23163                                                                  return 1416;
23164                                                                }
23165                                                            }
23166                                                          else
23167                                                            {
23168                                                              /* 33222222222211111111110000000000
23169                                                                 10987654321098765432109876543210
23170                                                                 001001x1xx1xxx1110xx100xxxxxxxxx
23171                                                                 uqdecp.  */
23172                                                              return 2047;
23173                                                            }
23174                                                        }
23175                                                    }
23176                                                  else
23177                                                    {
23178                                                      if (((word >> 17) & 0x1) == 0)
23179                                                        {
23180                                                          /* 33222222222211111111110000000000
23181                                                             10987654321098765432109876543210
23182                                                             001001x1xx1xxx0110xxx10xxxxxxxxx
23183                                                             uqincp.  */
23184                                                          return 2062;
23185                                                        }
23186                                                      else
23187                                                        {
23188                                                          /* 33222222222211111111110000000000
23189                                                             10987654321098765432109876543210
23190                                                             001001x1xx1xxx1110xxx10xxxxxxxxx
23191                                                             uqdecp.  */
23192                                                          return 2048;
23193                                                        }
23194                                                    }
23195                                                }
23196                                            }
23197                                          else
23198                                            {
23199                                              /* 33222222222211111111110000000000
23200                                                 10987654321098765432109876543210
23201                                                 001001x1xx1xxxxx10xxxx1xxxxxxxxx
23202                                                 cntp.  */
23203                                              return 2518;
23204                                            }
23205                                        }
23206                                      else
23207                                        {
23208                                          if (((word >> 13) & 0x1) == 0)
23209                                            {
23210                                              if (((word >> 23) & 0x1) == 0)
23211                                                {
23212                                                  /* 33222222222211111111110000000000
23213                                                     10987654321098765432109876543210
23214                                                     101001x10x1xxxxx100xxxxxxxxxxxxx
23215                                                     ld3q.  */
23216                                                  return 3314;
23217                                                }
23218                                              else
23219                                                {
23220                                                  /* 33222222222211111111110000000000
23221                                                     10987654321098765432109876543210
23222                                                     101001x11x1xxxxx100xxxxxxxxxxxxx
23223                                                     ld4q.  */
23224                                                  return 3315;
23225                                                }
23226                                            }
23227                                          else
23228                                            {
23229                                              if (((word >> 20) & 0x1) == 0)
23230                                                {
23231                                                  if (((word >> 22) & 0x1) == 0)
23232                                                    {
23233                                                      if (((word >> 23) & 0x1) == 0)
23234                                                        {
23235                                                          /* 33222222222211111111110000000000
23236                                                             10987654321098765432109876543210
23237                                                             101001x10010xxxx101xxxxxxxxxxxxx
23238                                                             ld1sh.  */
23239                                                          return 1633;
23240                                                        }
23241                                                      else
23242                                                        {
23243                                                          /* 33222222222211111111110000000000
23244                                                             10987654321098765432109876543210
23245                                                             101001x11010xxxx101xxxxxxxxxxxxx
23246                                                             ld1sb.  */
23247                                                          return 1620;
23248                                                        }
23249                                                    }
23250                                                  else
23251                                                    {
23252                                                      if (((word >> 23) & 0x1) == 0)
23253                                                        {
23254                                                          /* 33222222222211111111110000000000
23255                                                             10987654321098765432109876543210
23256                                                             101001x10110xxxx101xxxxxxxxxxxxx
23257                                                             ld1w.  */
23258                                                          return 1652;
23259                                                        }
23260                                                      else
23261                                                        {
23262                                                          /* 33222222222211111111110000000000
23263                                                             10987654321098765432109876543210
23264                                                             101001x11110xxxx101xxxxxxxxxxxxx
23265                                                             ld1d.  */
23266                                                          return 1572;
23267                                                        }
23268                                                    }
23269                                                }
23270                                              else
23271                                                {
23272                                                  if (((word >> 22) & 0x1) == 0)
23273                                                    {
23274                                                      if (((word >> 23) & 0x1) == 0)
23275                                                        {
23276                                                          /* 33222222222211111111110000000000
23277                                                             10987654321098765432109876543210
23278                                                             101001x10011xxxx101xxxxxxxxxxxxx
23279                                                             ldnf1sh.  */
23280                                                          return 1766;
23281                                                        }
23282                                                      else
23283                                                        {
23284                                                          /* 33222222222211111111110000000000
23285                                                             10987654321098765432109876543210
23286                                                             101001x11011xxxx101xxxxxxxxxxxxx
23287                                                             ldnf1sb.  */
23288                                                          return 1763;
23289                                                        }
23290                                                    }
23291                                                  else
23292                                                    {
23293                                                      if (((word >> 23) & 0x1) == 0)
23294                                                        {
23295                                                          /* 33222222222211111111110000000000
23296                                                             10987654321098765432109876543210
23297                                                             101001x10111xxxx101xxxxxxxxxxxxx
23298                                                             ldnf1w.  */
23299                                                          return 1769;
23300                                                        }
23301                                                      else
23302                                                        {
23303                                                          /* 33222222222211111111110000000000
23304                                                             10987654321098765432109876543210
23305                                                             101001x11111xxxx101xxxxxxxxxxxxx
23306                                                             ldnf1d.  */
23307                                                          return 1758;
23308                                                        }
23309                                                    }
23310                                                }
23311                                            }
23312                                        }
23313                                    }
23314                                  else
23315                                    {
23316                                      if (((word >> 31) & 0x1) == 0)
23317                                        {
23318                                          if (((word >> 16) & 0x1) == 0)
23319                                            {
23320                                              if (((word >> 17) & 0x1) == 0)
23321                                                {
23322                                                  if (((word >> 18) & 0x1) == 0)
23323                                                    {
23324                                                      if (((word >> 19) & 0x1) == 0)
23325                                                        {
23326                                                          if (((word >> 20) & 0x1) == 0)
23327                                                            {
23328                                                              /* 33222222222211111111110000000000
23329                                                                 10987654321098765432109876543210
23330                                                                 001001x1xx10000011xxxxxxxxxxxxxx
23331                                                                 add.  */
23332                                                              return 1329;
23333                                                            }
23334                                                          else
23335                                                            {
23336                                                              /* 33222222222211111111110000000000
23337                                                                 10987654321098765432109876543210
23338                                                                 001001x1xx11000011xxxxxxxxxxxxxx
23339                                                                 mul.  */
23340                                                              return 1799;
23341                                                            }
23342                                                        }
23343                                                      else
23344                                                        {
23345                                                          if (((word >> 20) & 0x1) == 0)
23346                                                            {
23347                                                              /* 33222222222211111111110000000000
23348                                                                 10987654321098765432109876543210
23349                                                                 001001x1xx10100011xxxxxxxxxxxxxx
23350                                                                 smax.  */
23351                                                              return 1879;
23352                                                            }
23353                                                          else
23354                                                            {
23355                                                              /* 33222222222211111111110000000000
23356                                                                 10987654321098765432109876543210
23357                                                                 001001x1xx11100011xxxxxxxxxxxxxx
23358                                                                 dup.  */
23359                                                              return 1421;
23360                                                            }
23361                                                        }
23362                                                    }
23363                                                  else
23364                                                    {
23365                                                      /* 33222222222211111111110000000000
23366                                                         10987654321098765432109876543210
23367                                                         001001x1xx1xx10011xxxxxxxxxxxxxx
23368                                                         sqadd.  */
23369                                                      return 1888;
23370                                                    }
23371                                                }
23372                                              else
23373                                                {
23374                                                  if (((word >> 18) & 0x1) == 0)
23375                                                    {
23376                                                      /* 33222222222211111111110000000000
23377                                                         10987654321098765432109876543210
23378                                                         001001x1xx1xx01011xxxxxxxxxxxxxx
23379                                                         smin.  */
23380                                                      return 1882;
23381                                                    }
23382                                                  else
23383                                                    {
23384                                                      /* 33222222222211111111110000000000
23385                                                         10987654321098765432109876543210
23386                                                         001001x1xx1xx11011xxxxxxxxxxxxxx
23387                                                         sqsub.  */
23388                                                      return 1918;
23389                                                    }
23390                                                }
23391                                            }
23392                                          else
23393                                            {
23394                                              if (((word >> 17) & 0x1) == 0)
23395                                                {
23396                                                  if (((word >> 18) & 0x1) == 0)
23397                                                    {
23398                                                      if (((word >> 19) & 0x1) == 0)
23399                                                        {
23400                                                          /* 33222222222211111111110000000000
23401                                                             10987654321098765432109876543210
23402                                                             001001x1xx1x000111xxxxxxxxxxxxxx
23403                                                             sub.  */
23404                                                          return 2001;
23405                                                        }
23406                                                      else
23407                                                        {
23408                                                          if (((word >> 20) & 0x1) == 0)
23409                                                            {
23410                                                              /* 33222222222211111111110000000000
23411                                                                 10987654321098765432109876543210
23412                                                                 001001x1xx10100111xxxxxxxxxxxxxx
23413                                                                 umax.  */
23414                                                              return 2029;
23415                                                            }
23416                                                          else
23417                                                            {
23418                                                              /* 33222222222211111111110000000000
23419                                                                 10987654321098765432109876543210
23420                                                                 001001x1xx11100111xxxxxxxxxxxxxx
23421                                                                 fdup.  */
23422                                                              return 1477;
23423                                                            }
23424                                                        }
23425                                                    }
23426                                                  else
23427                                                    {
23428                                                      /* 33222222222211111111110000000000
23429                                                         10987654321098765432109876543210
23430                                                         001001x1xx1xx10111xxxxxxxxxxxxxx
23431                                                         uqadd.  */
23432                                                      return 2037;
23433                                                    }
23434                                                }
23435                                              else
23436                                                {
23437                                                  if (((word >> 18) & 0x1) == 0)
23438                                                    {
23439                                                      if (((word >> 19) & 0x1) == 0)
23440                                                        {
23441                                                          /* 33222222222211111111110000000000
23442                                                             10987654321098765432109876543210
23443                                                             001001x1xx1x001111xxxxxxxxxxxxxx
23444                                                             subr.  */
23445                                                          return 2003;
23446                                                        }
23447                                                      else
23448                                                        {
23449                                                          /* 33222222222211111111110000000000
23450                                                             10987654321098765432109876543210
23451                                                             001001x1xx1x101111xxxxxxxxxxxxxx
23452                                                             umin.  */
23453                                                          return 2032;
23454                                                        }
23455                                                    }
23456                                                  else
23457                                                    {
23458                                                      /* 33222222222211111111110000000000
23459                                                         10987654321098765432109876543210
23460                                                         001001x1xx1xx11111xxxxxxxxxxxxxx
23461                                                         uqsub.  */
23462                                                      return 2067;
23463                                                    }
23464                                                }
23465                                            }
23466                                        }
23467                                      else
23468                                        {
23469                                          if (((word >> 13) & 0x1) == 0)
23470                                            {
23471                                              if (((word >> 22) & 0x1) == 0)
23472                                                {
23473                                                  if (((word >> 23) & 0x1) == 0)
23474                                                    {
23475                                                      /* 33222222222211111111110000000000
23476                                                         10987654321098765432109876543210
23477                                                         101001x1001xxxxx110xxxxxxxxxxxxx
23478                                                         ld2w.  */
23479                                                      return 1660;
23480                                                    }
23481                                                  else
23482                                                    {
23483                                                      /* 33222222222211111111110000000000
23484                                                         10987654321098765432109876543210
23485                                                         101001x1101xxxxx110xxxxxxxxxxxxx
23486                                                         ld2d.  */
23487                                                      return 1656;
23488                                                    }
23489                                                }
23490                                              else
23491                                                {
23492                                                  if (((word >> 23) & 0x1) == 0)
23493                                                    {
23494                                                      /* 33222222222211111111110000000000
23495                                                         10987654321098765432109876543210
23496                                                         101001x1011xxxxx110xxxxxxxxxxxxx
23497                                                         ld4w.  */
23498                                                      return 1676;
23499                                                    }
23500                                                  else
23501                                                    {
23502                                                      /* 33222222222211111111110000000000
23503                                                         10987654321098765432109876543210
23504                                                         101001x1111xxxxx110xxxxxxxxxxxxx
23505                                                         ld4d.  */
23506                                                      return 1672;
23507                                                    }
23508                                                }
23509                                            }
23510                                          else
23511                                            {
23512                                              if (((word >> 22) & 0x1) == 0)
23513                                                {
23514                                                  if (((word >> 23) & 0x1) == 0)
23515                                                    {
23516                                                      /* 33222222222211111111110000000000
23517                                                         10987654321098765432109876543210
23518                                                         101001x1001xxxxx111xxxxxxxxxxxxx
23519                                                         ld2w.  */
23520                                                      return 1661;
23521                                                    }
23522                                                  else
23523                                                    {
23524                                                      /* 33222222222211111111110000000000
23525                                                         10987654321098765432109876543210
23526                                                         101001x1101xxxxx111xxxxxxxxxxxxx
23527                                                         ld2d.  */
23528                                                      return 1657;
23529                                                    }
23530                                                }
23531                                              else
23532                                                {
23533                                                  if (((word >> 23) & 0x1) == 0)
23534                                                    {
23535                                                      /* 33222222222211111111110000000000
23536                                                         10987654321098765432109876543210
23537                                                         101001x1011xxxxx111xxxxxxxxxxxxx
23538                                                         ld4w.  */
23539                                                      return 1677;
23540                                                    }
23541                                                  else
23542                                                    {
23543                                                      /* 33222222222211111111110000000000
23544                                                         10987654321098765432109876543210
23545                                                         101001x1111xxxxx111xxxxxxxxxxxxx
23546                                                         ld4d.  */
23547                                                      return 1673;
23548                                                    }
23549                                                }
23550                                            }
23551                                        }
23552                                    }
23553                                }
23554                              else
23555                                {
23556                                  if (((word >> 13) & 0x1) == 0)
23557                                    {
23558                                      if (((word >> 31) & 0x1) == 0)
23559                                        {
23560                                          if (((word >> 14) & 0x1) == 0)
23561                                            {
23562                                              /* 33222222222211111111110000000000
23563                                                 10987654321098765432109876543210
23564                                                 011001x1xx1xxxxx100xxxxxxxxxxxxx
23565                                                 fmad.  */
23566                                              return 1479;
23567                                            }
23568                                          else
23569                                            {
23570                                              /* 33222222222211111111110000000000
23571                                                 10987654321098765432109876543210
23572                                                 011001x1xx1xxxxx110xxxxxxxxxxxxx
23573                                                 fnmad.  */
23574                                              return 1509;
23575                                            }
23576                                        }
23577                                      else
23578                                        {
23579                                          if (((word >> 22) & 0x1) == 0)
23580                                            {
23581                                              if (((word >> 23) & 0x1) == 0)
23582                                                {
23583                                                  /* 33222222222211111111110000000000
23584                                                     10987654321098765432109876543210
23585                                                     111001x1001xxxxx1x0xxxxxxxxxxxxx
23586                                                     st1w.  */
23587                                                  return 1955;
23588                                                }
23589                                              else
23590                                                {
23591                                                  /* 33222222222211111111110000000000
23592                                                     10987654321098765432109876543210
23593                                                     111001x1101xxxxx1x0xxxxxxxxxxxxx
23594                                                     st1d.  */
23595                                                  return 1934;
23596                                                }
23597                                            }
23598                                          else
23599                                            {
23600                                              /* 33222222222211111111110000000000
23601                                                 10987654321098765432109876543210
23602                                                 111001x1x11xxxxx1x0xxxxxxxxxxxxx
23603                                                 st1w.  */
23604                                              return 1960;
23605                                            }
23606                                        }
23607                                    }
23608                                  else
23609                                    {
23610                                      if (((word >> 14) & 0x1) == 0)
23611                                        {
23612                                          if (((word >> 31) & 0x1) == 0)
23613                                            {
23614                                              /* 33222222222211111111110000000000
23615                                                 10987654321098765432109876543210
23616                                                 011001x1xx1xxxxx101xxxxxxxxxxxxx
23617                                                 fmsb.  */
23618                                              return 1500;
23619                                            }
23620                                          else
23621                                            {
23622                                              if (((word >> 22) & 0x1) == 0)
23623                                                {
23624                                                  if (((word >> 23) & 0x1) == 0)
23625                                                    {
23626                                                      /* 33222222222211111111110000000000
23627                                                         10987654321098765432109876543210
23628                                                         111001x1001xxxxx101xxxxxxxxxxxxx
23629                                                         st1w.  */
23630                                                      return 1956;
23631                                                    }
23632                                                  else
23633                                                    {
23634                                                      /* 33222222222211111111110000000000
23635                                                         10987654321098765432109876543210
23636                                                         111001x1101xxxxx101xxxxxxxxxxxxx
23637                                                         st1d.  */
23638                                                      return 1935;
23639                                                    }
23640                                                }
23641                                              else
23642                                                {
23643                                                  /* 33222222222211111111110000000000
23644                                                     10987654321098765432109876543210
23645                                                     111001x1x11xxxxx101xxxxxxxxxxxxx
23646                                                     st1w.  */
23647                                                  return 1963;
23648                                                }
23649                                            }
23650                                        }
23651                                      else
23652                                        {
23653                                          if (((word >> 31) & 0x1) == 0)
23654                                            {
23655                                              /* 33222222222211111111110000000000
23656                                                 10987654321098765432109876543210
23657                                                 011001x1xx1xxxxx111xxxxxxxxxxxxx
23658                                                 fnmsb.  */
23659                                              return 1512;
23660                                            }
23661                                          else
23662                                            {
23663                                              if (((word >> 20) & 0x1) == 0)
23664                                                {
23665                                                  if (((word >> 23) & 0x1) == 0)
23666                                                    {
23667                                                      /* 33222222222211111111110000000000
23668                                                         10987654321098765432109876543210
23669                                                         111001x10x10xxxx111xxxxxxxxxxxxx
23670                                                         st1w.  */
23671                                                      return 1964;
23672                                                    }
23673                                                  else
23674                                                    {
23675                                                      /* 33222222222211111111110000000000
23676                                                         10987654321098765432109876543210
23677                                                         111001x11x10xxxx111xxxxxxxxxxxxx
23678                                                         st1d.  */
23679                                                      return 1938;
23680                                                    }
23681                                                }
23682                                              else
23683                                                {
23684                                                  if (((word >> 22) & 0x1) == 0)
23685                                                    {
23686                                                      if (((word >> 23) & 0x1) == 0)
23687                                                        {
23688                                                          /* 33222222222211111111110000000000
23689                                                             10987654321098765432109876543210
23690                                                             111001x10011xxxx111xxxxxxxxxxxxx
23691                                                             st2w.  */
23692                                                          return 1972;
23693                                                        }
23694                                                      else
23695                                                        {
23696                                                          /* 33222222222211111111110000000000
23697                                                             10987654321098765432109876543210
23698                                                             111001x11011xxxx111xxxxxxxxxxxxx
23699                                                             st2d.  */
23700                                                          return 1968;
23701                                                        }
23702                                                    }
23703                                                  else
23704                                                    {
23705                                                      if (((word >> 23) & 0x1) == 0)
23706                                                        {
23707                                                          /* 33222222222211111111110000000000
23708                                                             10987654321098765432109876543210
23709                                                             111001x10111xxxx111xxxxxxxxxxxxx
23710                                                             st4w.  */
23711                                                          return 1988;
23712                                                        }
23713                                                      else
23714                                                        {
23715                                                          /* 33222222222211111111110000000000
23716                                                             10987654321098765432109876543210
23717                                                             111001x11111xxxx111xxxxxxxxxxxxx
23718                                                             st4d.  */
23719                                                          return 1984;
23720                                                        }
23721                                                    }
23722                                                }
23723                                            }
23724                                        }
23725                                    }
23726                                }
23727                            }
23728                        }
23729                    }
23730                }
23731            }
23732          else
23733            {
23734              if (((word >> 29) & 0x1) == 0)
23735                {
23736                  if (((word >> 30) & 0x1) == 0)
23737                    {
23738                      if (((word >> 31) & 0x1) == 0)
23739                        {
23740                          /* 33222222222211111111110000000000
23741                             10987654321098765432109876543210
23742                             000101xxxxxxxxxxxxxxxxxxxxxxxxxx
23743                             b.  */
23744                          return 636;
23745                        }
23746                      else
23747                        {
23748                          /* 33222222222211111111110000000000
23749                             10987654321098765432109876543210
23750                             100101xxxxxxxxxxxxxxxxxxxxxxxxxx
23751                             bl.  */
23752                          return 637;
23753                        }
23754                    }
23755                  else
23756                    {
23757                      if (((word >> 24) & 0x1) == 0)
23758                        {
23759                          if (((word >> 4) & 0x1) == 0)
23760                            {
23761                              if (((word >> 25) & 0x1) == 0)
23762                                {
23763                                  if (((word >> 31) & 0x1) == 0)
23764                                    {
23765                                      /* 33222222222211111111110000000000
23766                                         10987654321098765432109876543210
23767                                         01010100xxxxxxxxxxxxxxxxxxx0xxxx
23768                                         b.c.  */
23769                                      return 657;
23770                                    }
23771                                  else
23772                                    {
23773                                      if (((word >> 0) & 0x1) == 0)
23774                                        {
23775                                          if (((word >> 1) & 0x1) == 0)
23776                                            {
23777                                              if (((word >> 21) & 0x1) == 0)
23778                                                {
23779                                                  /* 33222222222211111111110000000000
23780                                                     10987654321098765432109876543210
23781                                                     11010100xx0xxxxxxxxxxxxxxxx0xx00
23782                                                     hlt.  */
23783                                                  return 753;
23784                                                }
23785                                              else
23786                                                {
23787                                                  if (((word >> 22) & 0x1) == 0)
23788                                                    {
23789                                                      /* 33222222222211111111110000000000
23790                                                         10987654321098765432109876543210
23791                                                         11010100x01xxxxxxxxxxxxxxxx0xx00
23792                                                         brk.  */
23793                                                      return 752;
23794                                                    }
23795                                                  else
23796                                                    {
23797                                                      /* 33222222222211111111110000000000
23798                                                         10987654321098765432109876543210
23799                                                         11010100x11xxxxxxxxxxxxxxxx0xx00
23800                                                         tcancel.  */
23801                                                      return 1216;
23802                                                    }
23803                                                }
23804                                            }
23805                                          else
23806                                            {
23807                                              if (((word >> 21) & 0x1) == 0)
23808                                                {
23809                                                  /* 33222222222211111111110000000000
23810                                                     10987654321098765432109876543210
23811                                                     11010100xx0xxxxxxxxxxxxxxxx0xx10
23812                                                     hvc.  */
23813                                                  return 750;
23814                                                }
23815                                              else
23816                                                {
23817                                                  /* 33222222222211111111110000000000
23818                                                     10987654321098765432109876543210
23819                                                     11010100xx1xxxxxxxxxxxxxxxx0xx10
23820                                                     dcps2.  */
23821                                                  return 756;
23822                                                }
23823                                            }
23824                                        }
23825                                      else
23826                                        {
23827                                          if (((word >> 1) & 0x1) == 0)
23828                                            {
23829                                              if (((word >> 21) & 0x1) == 0)
23830                                                {
23831                                                  /* 33222222222211111111110000000000
23832                                                     10987654321098765432109876543210
23833                                                     11010100xx0xxxxxxxxxxxxxxxx0xx01
23834                                                     svc.  */
23835                                                  return 749;
23836                                                }
23837                                              else
23838                                                {
23839                                                  /* 33222222222211111111110000000000
23840                                                     10987654321098765432109876543210
23841                                                     11010100xx1xxxxxxxxxxxxxxxx0xx01
23842                                                     dcps1.  */
23843                                                  return 755;
23844                                                }
23845                                            }
23846                                          else
23847                                            {
23848                                              if (((word >> 21) & 0x1) == 0)
23849                                                {
23850                                                  /* 33222222222211111111110000000000
23851                                                     10987654321098765432109876543210
23852                                                     11010100xx0xxxxxxxxxxxxxxxx0xx11
23853                                                     smc.  */
23854                                                  return 751;
23855                                                }
23856                                              else
23857                                                {
23858                                                  /* 33222222222211111111110000000000
23859                                                     10987654321098765432109876543210
23860                                                     11010100xx1xxxxxxxxxxxxxxxx0xx11
23861                                                     dcps3.  */
23862                                                  return 757;
23863                                                }
23864                                            }
23865                                        }
23866                                    }
23867                                }
23868                              else
23869                                {
23870                                  if (((word >> 21) & 0x1) == 0)
23871                                    {
23872                                      if (((word >> 22) & 0x1) == 0)
23873                                        {
23874                                          if (((word >> 23) & 0x1) == 0)
23875                                            {
23876                                              /* 33222222222211111111110000000000
23877                                                 10987654321098765432109876543210
23878                                                 x1010110000xxxxxxxxxxxxxxxx0xxxx
23879                                                 br.  */
23880                                              return 638;
23881                                            }
23882                                          else
23883                                            {
23884                                              /* 33222222222211111111110000000000
23885                                                 10987654321098765432109876543210
23886                                                 x1010110100xxxxxxxxxxxxxxxx0xxxx
23887                                                 eret.  */
23888                                              return 641;
23889                                            }
23890                                        }
23891                                      else
23892                                        {
23893                                          /* 33222222222211111111110000000000
23894                                             10987654321098765432109876543210
23895                                             x1010110x10xxxxxxxxxxxxxxxx0xxxx
23896                                             ret.  */
23897                                          return 640;
23898                                        }
23899                                    }
23900                                  else
23901                                    {
23902                                      if (((word >> 23) & 0x1) == 0)
23903                                        {
23904                                          /* 33222222222211111111110000000000
23905                                             10987654321098765432109876543210
23906                                             x10101100x1xxxxxxxxxxxxxxxx0xxxx
23907                                             blr.  */
23908                                          return 639;
23909                                        }
23910                                      else
23911                                        {
23912                                          /* 33222222222211111111110000000000
23913                                             10987654321098765432109876543210
23914                                             x10101101x1xxxxxxxxxxxxxxxx0xxxx
23915                                             drps.  */
23916                                          return 642;
23917                                        }
23918                                    }
23919                                }
23920                            }
23921                          else
23922                            {
23923                              if (((word >> 25) & 0x1) == 0)
23924                                {
23925                                  /* 33222222222211111111110000000000
23926                                     10987654321098765432109876543210
23927                                     x1010100xxxxxxxxxxxxxxxxxxx1xxxx
23928                                     bc.c.  */
23929                                  return 3193;
23930                                }
23931                              else
23932                                {
23933                                  if (((word >> 10) & 0x1) == 0)
23934                                    {
23935                                      if (((word >> 21) & 0x1) == 0)
23936                                        {
23937                                          if (((word >> 22) & 0x1) == 0)
23938                                            {
23939                                              if (((word >> 23) & 0x1) == 0)
23940                                                {
23941                                                  /* 33222222222211111111110000000000
23942                                                     10987654321098765432109876543210
23943                                                     x1010110000xxxxxxxxxx0xxxxx1xxxx
23944                                                     braaz.  */
23945                                                  return 647;
23946                                                }
23947                                              else
23948                                                {
23949                                                  /* 33222222222211111111110000000000
23950                                                     10987654321098765432109876543210
23951                                                     x1010110100xxxxxxxxxx0xxxxx1xxxx
23952                                                     eretaa.  */
23953                                                  return 653;
23954                                                }
23955                                            }
23956                                          else
23957                                            {
23958                                              /* 33222222222211111111110000000000
23959                                                 10987654321098765432109876543210
23960                                                 x1010110x10xxxxxxxxxx0xxxxx1xxxx
23961                                                 retaa.  */
23962                                              return 651;
23963                                            }
23964                                        }
23965                                      else
23966                                        {
23967                                          /* 33222222222211111111110000000000
23968                                             10987654321098765432109876543210
23969                                             x1010110xx1xxxxxxxxxx0xxxxx1xxxx
23970                                             blraaz.  */
23971                                          return 649;
23972                                        }
23973                                    }
23974                                  else
23975                                    {
23976                                      if (((word >> 21) & 0x1) == 0)
23977                                        {
23978                                          if (((word >> 22) & 0x1) == 0)
23979                                            {
23980                                              if (((word >> 23) & 0x1) == 0)
23981                                                {
23982                                                  /* 33222222222211111111110000000000
23983                                                     10987654321098765432109876543210
23984                                                     x1010110000xxxxxxxxxx1xxxxx1xxxx
23985                                                     brabz.  */
23986                                                  return 648;
23987                                                }
23988                                              else
23989                                                {
23990                                                  /* 33222222222211111111110000000000
23991                                                     10987654321098765432109876543210
23992                                                     x1010110100xxxxxxxxxx1xxxxx1xxxx
23993                                                     eretab.  */
23994                                                  return 654;
23995                                                }
23996                                            }
23997                                          else
23998                                            {
23999                                              /* 33222222222211111111110000000000
24000                                                 10987654321098765432109876543210
24001                                                 x1010110x10xxxxxxxxxx1xxxxx1xxxx
24002                                                 retab.  */
24003                                              return 652;
24004                                            }
24005                                        }
24006                                      else
24007                                        {
24008                                          /* 33222222222211111111110000000000
24009                                             10987654321098765432109876543210
24010                                             x1010110xx1xxxxxxxxxx1xxxxx1xxxx
24011                                             blrabz.  */
24012                                          return 650;
24013                                        }
24014                                    }
24015                                }
24016                            }
24017                        }
24018                      else
24019                        {
24020                          if (((word >> 21) & 0x1) == 0)
24021                            {
24022                              if (((word >> 22) & 0x1) == 0)
24023                                {
24024                                  if (((word >> 25) & 0x1) == 0)
24025                                    {
24026                                      /* 33222222222211111111110000000000
24027                                         10987654321098765432109876543210
24028                                         x1010101x00xxxxxxxxxxxxxxxxxxxxx
24029                                         xaflag.  */
24030                                      return 811;
24031                                    }
24032                                  else
24033                                    {
24034                                      if (((word >> 10) & 0x1) == 0)
24035                                        {
24036                                          /* 33222222222211111111110000000000
24037                                             10987654321098765432109876543210
24038                                             x1010111x00xxxxxxxxxx0xxxxxxxxxx
24039                                             braa.  */
24040                                          return 643;
24041                                        }
24042                                      else
24043                                        {
24044                                          /* 33222222222211111111110000000000
24045                                             10987654321098765432109876543210
24046                                             x1010111x00xxxxxxxxxx1xxxxxxxxxx
24047                                             brab.  */
24048                                          return 644;
24049                                        }
24050                                    }
24051                                }
24052                              else
24053                                {
24054                                  if (((word >> 20) & 0x1) == 0)
24055                                    {
24056                                      /* 33222222222211111111110000000000
24057                                         10987654321098765432109876543210
24058                                         x10101x1x100xxxxxxxxxxxxxxxxxxxx
24059                                         sysp.  */
24060                                      return 1263;
24061                                    }
24062                                  else
24063                                    {
24064                                      /* 33222222222211111111110000000000
24065                                         10987654321098765432109876543210
24066                                         x10101x1x101xxxxxxxxxxxxxxxxxxxx
24067                                         msrr.  */
24068                                      return 1280;
24069                                    }
24070                                }
24071                            }
24072                          else
24073                            {
24074                              if (((word >> 22) & 0x1) == 0)
24075                                {
24076                                  if (((word >> 25) & 0x1) == 0)
24077                                    {
24078                                      /* 33222222222211111111110000000000
24079                                         10987654321098765432109876543210
24080                                         x1010101x01xxxxxxxxxxxxxxxxxxxxx
24081                                         tstart.  */
24082                                      return 1213;
24083                                    }
24084                                  else
24085                                    {
24086                                      if (((word >> 10) & 0x1) == 0)
24087                                        {
24088                                          /* 33222222222211111111110000000000
24089                                             10987654321098765432109876543210
24090                                             x1010111x01xxxxxxxxxx0xxxxxxxxxx
24091                                             blraa.  */
24092                                          return 645;
24093                                        }
24094                                      else
24095                                        {
24096                                          /* 33222222222211111111110000000000
24097                                             10987654321098765432109876543210
24098                                             x1010111x01xxxxxxxxxx1xxxxxxxxxx
24099                                             blrab.  */
24100                                          return 646;
24101                                        }
24102                                    }
24103                                }
24104                              else
24105                                {
24106                                  /* 33222222222211111111110000000000
24107                                     10987654321098765432109876543210
24108                                     x10101x1x11xxxxxxxxxxxxxxxxxxxxx
24109                                     mrrs.  */
24110                                  return 1279;
24111                                }
24112                            }
24113                        }
24114                    }
24115                }
24116              else
24117                {
24118                  if (((word >> 24) & 0x1) == 0)
24119                    {
24120                      if (((word >> 25) & 0x1) == 0)
24121                        {
24122                          /* 33222222222211111111110000000000
24123                             10987654321098765432109876543210
24124                             xx110100xxxxxxxxxxxxxxxxxxxxxxxx
24125                             cbz.  */
24126                          return 655;
24127                        }
24128                      else
24129                        {
24130                          /* 33222222222211111111110000000000
24131                             10987654321098765432109876543210
24132                             xx110110xxxxxxxxxxxxxxxxxxxxxxxx
24133                             tbz.  */
24134                          return 1289;
24135                        }
24136                    }
24137                  else
24138                    {
24139                      if (((word >> 25) & 0x1) == 0)
24140                        {
24141                          /* 33222222222211111111110000000000
24142                             10987654321098765432109876543210
24143                             xx110101xxxxxxxxxxxxxxxxxxxxxxxx
24144                             cbnz.  */
24145                          return 656;
24146                        }
24147                      else
24148                        {
24149                          /* 33222222222211111111110000000000
24150                             10987654321098765432109876543210
24151                             xx110111xxxxxxxxxxxxxxxxxxxxxxxx
24152                             tbnz.  */
24153                          return 1290;
24154                        }
24155                    }
24156                }
24157            }
24158        }
24159      else
24160        {
24161          if (((word >> 25) & 0x1) == 0)
24162            {
24163              if (((word >> 28) & 0x1) == 0)
24164                {
24165                  if (((word >> 22) & 0x1) == 0)
24166                    {
24167                      if (((word >> 23) & 0x1) == 0)
24168                        {
24169                          if (((word >> 24) & 0x1) == 0)
24170                            {
24171                              if (((word >> 29) & 0x1) == 0)
24172                                {
24173                                  /* 33222222222211111111110000000000
24174                                     10987654321098765432109876543210
24175                                     xx00110000xxxxxxxxxxxxxxxxxxxxxx
24176                                     st4.  */
24177                                  return 440;
24178                                }
24179                              else
24180                                {
24181                                  /* 33222222222211111111110000000000
24182                                     10987654321098765432109876543210
24183                                     xx10110000xxxxxxxxxxxxxxxxxxxxxx
24184                                     stnp.  */
24185                                  return 973;
24186                                }
24187                            }
24188                          else
24189                            {
24190                              if (((word >> 29) & 0x1) == 0)
24191                                {
24192                                  if (((word >> 13) & 0x1) == 0)
24193                                    {
24194                                      if (((word >> 16) & 0x1) == 0)
24195                                        {
24196                                          if (((word >> 21) & 0x1) == 0)
24197                                            {
24198                                              /* 33222222222211111111110000000000
24199                                                 10987654321098765432109876543210
24200                                                 xx001101000xxxx0xx0xxxxxxxxxxxxx
24201                                                 st1.  */
24202                                              return 456;
24203                                            }
24204                                          else
24205                                            {
24206                                              /* 33222222222211111111110000000000
24207                                                 10987654321098765432109876543210
24208                                                 xx001101001xxxx0xx0xxxxxxxxxxxxx
24209                                                 st2.  */
24210                                              return 458;
24211                                            }
24212                                        }
24213                                      else
24214                                        {
24215                                          /* 33222222222211111111110000000000
24216                                             10987654321098765432109876543210
24217                                             xx00110100xxxxx1xx0xxxxxxxxxxxxx
24218                                             stl1.  */
24219                                          return 1202;
24220                                        }
24221                                    }
24222                                  else
24223                                    {
24224                                      if (((word >> 21) & 0x1) == 0)
24225                                        {
24226                                          /* 33222222222211111111110000000000
24227                                             10987654321098765432109876543210
24228                                             xx001101000xxxxxxx1xxxxxxxxxxxxx
24229                                             st3.  */
24230                                          return 457;
24231                                        }
24232                                      else
24233                                        {
24234                                          /* 33222222222211111111110000000000
24235                                             10987654321098765432109876543210
24236                                             xx001101001xxxxxxx1xxxxxxxxxxxxx
24237                                             st4.  */
24238                                          return 459;
24239                                        }
24240                                    }
24241                                }
24242                              else
24243                                {
24244                                  /* 33222222222211111111110000000000
24245                                     10987654321098765432109876543210
24246                                     xx10110100xxxxxxxxxxxxxxxxxxxxxx
24247                                     stp.  */
24248                                  return 977;
24249                                }
24250                            }
24251                        }
24252                      else
24253                        {
24254                          if (((word >> 29) & 0x1) == 0)
24255                            {
24256                              if (((word >> 21) & 0x1) == 0)
24257                                {
24258                                  if (((word >> 24) & 0x1) == 0)
24259                                    {
24260                                      /* 33222222222211111111110000000000
24261                                         10987654321098765432109876543210
24262                                         xx001100100xxxxxxxxxxxxxxxxxxxxx
24263                                         st4.  */
24264                                      return 448;
24265                                    }
24266                                  else
24267                                    {
24268                                      if (((word >> 13) & 0x1) == 0)
24269                                        {
24270                                          /* 33222222222211111111110000000000
24271                                             10987654321098765432109876543210
24272                                             xx001101100xxxxxxx0xxxxxxxxxxxxx
24273                                             st1.  */
24274                                          return 468;
24275                                        }
24276                                      else
24277                                        {
24278                                          /* 33222222222211111111110000000000
24279                                             10987654321098765432109876543210
24280                                             xx001101100xxxxxxx1xxxxxxxxxxxxx
24281                                             st3.  */
24282                                          return 469;
24283                                        }
24284                                    }
24285                                }
24286                              else
24287                                {
24288                                  if (((word >> 13) & 0x1) == 0)
24289                                    {
24290                                      /* 33222222222211111111110000000000
24291                                         10987654321098765432109876543210
24292                                         xx00110x101xxxxxxx0xxxxxxxxxxxxx
24293                                         st2.  */
24294                                      return 470;
24295                                    }
24296                                  else
24297                                    {
24298                                      /* 33222222222211111111110000000000
24299                                         10987654321098765432109876543210
24300                                         xx00110x101xxxxxxx1xxxxxxxxxxxxx
24301                                         st4.  */
24302                                      return 471;
24303                                    }
24304                                }
24305                            }
24306                          else
24307                            {
24308                              /* 33222222222211111111110000000000
24309                                 10987654321098765432109876543210
24310                                 xx10110x10xxxxxxxxxxxxxxxxxxxxxx
24311                                 stp.  */
24312                              return 983;
24313                            }
24314                        }
24315                    }
24316                  else
24317                    {
24318                      if (((word >> 23) & 0x1) == 0)
24319                        {
24320                          if (((word >> 24) & 0x1) == 0)
24321                            {
24322                              if (((word >> 29) & 0x1) == 0)
24323                                {
24324                                  /* 33222222222211111111110000000000
24325                                     10987654321098765432109876543210
24326                                     xx00110001xxxxxxxxxxxxxxxxxxxxxx
24327                                     ld4.  */
24328                                  return 444;
24329                                }
24330                              else
24331                                {
24332                                  /* 33222222222211111111110000000000
24333                                     10987654321098765432109876543210
24334                                     xx10110001xxxxxxxxxxxxxxxxxxxxxx
24335                                     ldnp.  */
24336                                  return 974;
24337                                }
24338                            }
24339                          else
24340                            {
24341                              if (((word >> 29) & 0x1) == 0)
24342                                {
24343                                  if (((word >> 13) & 0x1) == 0)
24344                                    {
24345                                      if (((word >> 16) & 0x1) == 0)
24346                                        {
24347                                          if (((word >> 21) & 0x1) == 0)
24348                                            {
24349                                              /* 33222222222211111111110000000000
24350                                                 10987654321098765432109876543210
24351                                                 xx001101010xxxx0xx0xxxxxxxxxxxxx
24352                                                 ld1.  */
24353                                              return 460;
24354                                            }
24355                                          else
24356                                            {
24357                                              /* 33222222222211111111110000000000
24358                                                 10987654321098765432109876543210
24359                                                 xx001101011xxxx0xx0xxxxxxxxxxxxx
24360                                                 ld2.  */
24361                                              return 464;
24362                                            }
24363                                        }
24364                                      else
24365                                        {
24366                                          /* 33222222222211111111110000000000
24367                                             10987654321098765432109876543210
24368                                             xx00110101xxxxx1xx0xxxxxxxxxxxxx
24369                                             ldap1.  */
24370                                          return 1203;
24371                                        }
24372                                    }
24373                                  else
24374                                    {
24375                                      if (((word >> 21) & 0x1) == 0)
24376                                        {
24377                                          /* 33222222222211111111110000000000
24378                                             10987654321098765432109876543210
24379                                             xx001101010xxxxxxx1xxxxxxxxxxxxx
24380                                             ld3.  */
24381                                          return 461;
24382                                        }
24383                                      else
24384                                        {
24385                                          /* 33222222222211111111110000000000
24386                                             10987654321098765432109876543210
24387                                             xx001101011xxxxxxx1xxxxxxxxxxxxx
24388                                             ld4.  */
24389                                          return 465;
24390                                        }
24391                                    }
24392                                }
24393                              else
24394                                {
24395                                  /* 33222222222211111111110000000000
24396                                     10987654321098765432109876543210
24397                                     xx10110101xxxxxxxxxxxxxxxxxxxxxx
24398                                     ldp.  */
24399                                  return 978;
24400                                }
24401                            }
24402                        }
24403                      else
24404                        {
24405                          if (((word >> 29) & 0x1) == 0)
24406                            {
24407                              if (((word >> 21) & 0x1) == 0)
24408                                {
24409                                  if (((word >> 24) & 0x1) == 0)
24410                                    {
24411                                      /* 33222222222211111111110000000000
24412                                         10987654321098765432109876543210
24413                                         xx001100110xxxxxxxxxxxxxxxxxxxxx
24414                                         ld4.  */
24415                                      return 452;
24416                                    }
24417                                  else
24418                                    {
24419                                      if (((word >> 13) & 0x1) == 0)
24420                                        {
24421                                          /* 33222222222211111111110000000000
24422                                             10987654321098765432109876543210
24423                                             xx001101110xxxxxxx0xxxxxxxxxxxxx
24424                                             ld1.  */
24425                                          return 472;
24426                                        }
24427                                      else
24428                                        {
24429                                          /* 33222222222211111111110000000000
24430                                             10987654321098765432109876543210
24431                                             xx001101110xxxxxxx1xxxxxxxxxxxxx
24432                                             ld3.  */
24433                                          return 473;
24434                                        }
24435                                    }
24436                                }
24437                              else
24438                                {
24439                                  if (((word >> 13) & 0x1) == 0)
24440                                    {
24441                                      /* 33222222222211111111110000000000
24442                                         10987654321098765432109876543210
24443                                         xx00110x111xxxxxxx0xxxxxxxxxxxxx
24444                                         ld2.  */
24445                                      return 476;
24446                                    }
24447                                  else
24448                                    {
24449                                      /* 33222222222211111111110000000000
24450                                         10987654321098765432109876543210
24451                                         xx00110x111xxxxxxx1xxxxxxxxxxxxx
24452                                         ld4.  */
24453                                      return 477;
24454                                    }
24455                                }
24456                            }
24457                          else
24458                            {
24459                              /* 33222222222211111111110000000000
24460                                 10987654321098765432109876543210
24461                                 xx10110x11xxxxxxxxxxxxxxxxxxxxxx
24462                                 ldp.  */
24463                              return 984;
24464                            }
24465                        }
24466                    }
24467                }
24468              else
24469                {
24470                  if (((word >> 24) & 0x1) == 0)
24471                    {
24472                      if (((word >> 29) & 0x1) == 0)
24473                        {
24474                          /* 33222222222211111111110000000000
24475                             10987654321098765432109876543210
24476                             xx011100xxxxxxxxxxxxxxxxxxxxxxxx
24477                             ldr.  */
24478                          return 988;
24479                        }
24480                      else
24481                        {
24482                          if (((word >> 10) & 0x1) == 0)
24483                            {
24484                              if (((word >> 11) & 0x1) == 0)
24485                                {
24486                                  if (((word >> 22) & 0x1) == 0)
24487                                    {
24488                                      /* 33222222222211111111110000000000
24489                                         10987654321098765432109876543210
24490                                         xx111100x0xxxxxxxxxx00xxxxxxxxxx
24491                                         stur.  */
24492                                      return 925;
24493                                    }
24494                                  else
24495                                    {
24496                                      /* 33222222222211111111110000000000
24497                                         10987654321098765432109876543210
24498                                         xx111100x1xxxxxxxxxx00xxxxxxxxxx
24499                                         ldur.  */
24500                                      return 926;
24501                                    }
24502                                }
24503                              else
24504                                {
24505                                  if (((word >> 22) & 0x1) == 0)
24506                                    {
24507                                      /* 33222222222211111111110000000000
24508                                         10987654321098765432109876543210
24509                                         xx111100x0xxxxxxxxxx10xxxxxxxxxx
24510                                         str.  */
24511                                      return 904;
24512                                    }
24513                                  else
24514                                    {
24515                                      /* 33222222222211111111110000000000
24516                                         10987654321098765432109876543210
24517                                         xx111100x1xxxxxxxxxx10xxxxxxxxxx
24518                                         ldr.  */
24519                                      return 905;
24520                                    }
24521                                }
24522                            }
24523                          else
24524                            {
24525                              if (((word >> 22) & 0x1) == 0)
24526                                {
24527                                  /* 33222222222211111111110000000000
24528                                     10987654321098765432109876543210
24529                                     xx111100x0xxxxxxxxxxx1xxxxxxxxxx
24530                                     str.  */
24531                                  return 873;
24532                                }
24533                              else
24534                                {
24535                                  /* 33222222222211111111110000000000
24536                                     10987654321098765432109876543210
24537                                     xx111100x1xxxxxxxxxxx1xxxxxxxxxx
24538                                     ldr.  */
24539                                  return 874;
24540                                }
24541                            }
24542                        }
24543                    }
24544                  else
24545                    {
24546                      if (((word >> 22) & 0x1) == 0)
24547                        {
24548                          if (((word >> 29) & 0x1) == 0)
24549                            {
24550                              if (((word >> 10) & 0x1) == 0)
24551                                {
24552                                  /* 33222222222211111111110000000000
24553                                     10987654321098765432109876543210
24554                                     xx011101x0xxxxxxxxxxx0xxxxxxxxxx
24555                                     stlur.  */
24556                                  return 1205;
24557                                }
24558                              else
24559                                {
24560                                  if (((word >> 12) & 0x1) == 0)
24561                                    {
24562                                      if (((word >> 13) & 0x1) == 0)
24563                                        {
24564                                          if (((word >> 14) & 0x1) == 0)
24565                                            {
24566                                              if (((word >> 15) & 0x1) == 0)
24567                                                {
24568                                                  if (((word >> 23) & 0x1) == 0)
24569                                                    {
24570                                                      /* 33222222222211111111110000000000
24571                                                         10987654321098765432109876543210
24572                                                         xx01110100xxxxxx0000x1xxxxxxxxxx
24573                                                         cpyp.  */
24574                                                      return 3121;
24575                                                    }
24576                                                  else
24577                                                    {
24578                                                      /* 33222222222211111111110000000000
24579                                                         10987654321098765432109876543210
24580                                                         xx01110110xxxxxx0000x1xxxxxxxxxx
24581                                                         cpye.  */
24582                                                      return 3123;
24583                                                    }
24584                                                }
24585                                              else
24586                                                {
24587                                                  if (((word >> 23) & 0x1) == 0)
24588                                                    {
24589                                                      /* 33222222222211111111110000000000
24590                                                         10987654321098765432109876543210
24591                                                         xx01110100xxxxxx1000x1xxxxxxxxxx
24592                                                         cpyprn.  */
24593                                                      return 3127;
24594                                                    }
24595                                                  else
24596                                                    {
24597                                                      /* 33222222222211111111110000000000
24598                                                         10987654321098765432109876543210
24599                                                         xx01110110xxxxxx1000x1xxxxxxxxxx
24600                                                         cpyern.  */
24601                                                      return 3129;
24602                                                    }
24603                                                }
24604                                            }
24605                                          else
24606                                            {
24607                                              if (((word >> 15) & 0x1) == 0)
24608                                                {
24609                                                  if (((word >> 23) & 0x1) == 0)
24610                                                    {
24611                                                      /* 33222222222211111111110000000000
24612                                                         10987654321098765432109876543210
24613                                                         xx01110100xxxxxx0100x1xxxxxxxxxx
24614                                                         cpypwn.  */
24615                                                      return 3124;
24616                                                    }
24617                                                  else
24618                                                    {
24619                                                      /* 33222222222211111111110000000000
24620                                                         10987654321098765432109876543210
24621                                                         xx01110110xxxxxx0100x1xxxxxxxxxx
24622                                                         cpyewn.  */
24623                                                      return 3126;
24624                                                    }
24625                                                }
24626                                              else
24627                                                {
24628                                                  if (((word >> 23) & 0x1) == 0)
24629                                                    {
24630                                                      /* 33222222222211111111110000000000
24631                                                         10987654321098765432109876543210
24632                                                         xx01110100xxxxxx1100x1xxxxxxxxxx
24633                                                         cpypn.  */
24634                                                      return 3130;
24635                                                    }
24636                                                  else
24637                                                    {
24638                                                      /* 33222222222211111111110000000000
24639                                                         10987654321098765432109876543210
24640                                                         xx01110110xxxxxx1100x1xxxxxxxxxx
24641                                                         cpyen.  */
24642                                                      return 3132;
24643                                                    }
24644                                                }
24645                                            }
24646                                        }
24647                                      else
24648                                        {
24649                                          if (((word >> 14) & 0x1) == 0)
24650                                            {
24651                                              if (((word >> 15) & 0x1) == 0)
24652                                                {
24653                                                  if (((word >> 23) & 0x1) == 0)
24654                                                    {
24655                                                      /* 33222222222211111111110000000000
24656                                                         10987654321098765432109876543210
24657                                                         xx01110100xxxxxx0010x1xxxxxxxxxx
24658                                                         cpyprt.  */
24659                                                      return 3145;
24660                                                    }
24661                                                  else
24662                                                    {
24663                                                      /* 33222222222211111111110000000000
24664                                                         10987654321098765432109876543210
24665                                                         xx01110110xxxxxx0010x1xxxxxxxxxx
24666                                                         cpyert.  */
24667                                                      return 3147;
24668                                                    }
24669                                                }
24670                                              else
24671                                                {
24672                                                  if (((word >> 23) & 0x1) == 0)
24673                                                    {
24674                                                      /* 33222222222211111111110000000000
24675                                                         10987654321098765432109876543210
24676                                                         xx01110100xxxxxx1010x1xxxxxxxxxx
24677                                                         cpyprtrn.  */
24678                                                      return 3151;
24679                                                    }
24680                                                  else
24681                                                    {
24682                                                      /* 33222222222211111111110000000000
24683                                                         10987654321098765432109876543210
24684                                                         xx01110110xxxxxx1010x1xxxxxxxxxx
24685                                                         cpyertrn.  */
24686                                                      return 3153;
24687                                                    }
24688                                                }
24689                                            }
24690                                          else
24691                                            {
24692                                              if (((word >> 15) & 0x1) == 0)
24693                                                {
24694                                                  if (((word >> 23) & 0x1) == 0)
24695                                                    {
24696                                                      /* 33222222222211111111110000000000
24697                                                         10987654321098765432109876543210
24698                                                         xx01110100xxxxxx0110x1xxxxxxxxxx
24699                                                         cpyprtwn.  */
24700                                                      return 3148;
24701                                                    }
24702                                                  else
24703                                                    {
24704                                                      /* 33222222222211111111110000000000
24705                                                         10987654321098765432109876543210
24706                                                         xx01110110xxxxxx0110x1xxxxxxxxxx
24707                                                         cpyertwn.  */
24708                                                      return 3150;
24709                                                    }
24710                                                }
24711                                              else
24712                                                {
24713                                                  if (((word >> 23) & 0x1) == 0)
24714                                                    {
24715                                                      /* 33222222222211111111110000000000
24716                                                         10987654321098765432109876543210
24717                                                         xx01110100xxxxxx1110x1xxxxxxxxxx
24718                                                         cpyprtn.  */
24719                                                      return 3154;
24720                                                    }
24721                                                  else
24722                                                    {
24723                                                      /* 33222222222211111111110000000000
24724                                                         10987654321098765432109876543210
24725                                                         xx01110110xxxxxx1110x1xxxxxxxxxx
24726                                                         cpyertn.  */
24727                                                      return 3156;
24728                                                    }
24729                                                }
24730                                            }
24731                                        }
24732                                    }
24733                                  else
24734                                    {
24735                                      if (((word >> 13) & 0x1) == 0)
24736                                        {
24737                                          if (((word >> 14) & 0x1) == 0)
24738                                            {
24739                                              if (((word >> 15) & 0x1) == 0)
24740                                                {
24741                                                  if (((word >> 23) & 0x1) == 0)
24742                                                    {
24743                                                      /* 33222222222211111111110000000000
24744                                                         10987654321098765432109876543210
24745                                                         xx01110100xxxxxx0001x1xxxxxxxxxx
24746                                                         cpypwt.  */
24747                                                      return 3133;
24748                                                    }
24749                                                  else
24750                                                    {
24751                                                      /* 33222222222211111111110000000000
24752                                                         10987654321098765432109876543210
24753                                                         xx01110110xxxxxx0001x1xxxxxxxxxx
24754                                                         cpyewt.  */
24755                                                      return 3135;
24756                                                    }
24757                                                }
24758                                              else
24759                                                {
24760                                                  if (((word >> 23) & 0x1) == 0)
24761                                                    {
24762                                                      /* 33222222222211111111110000000000
24763                                                         10987654321098765432109876543210
24764                                                         xx01110100xxxxxx1001x1xxxxxxxxxx
24765                                                         cpypwtrn.  */
24766                                                      return 3139;
24767                                                    }
24768                                                  else
24769                                                    {
24770                                                      /* 33222222222211111111110000000000
24771                                                         10987654321098765432109876543210
24772                                                         xx01110110xxxxxx1001x1xxxxxxxxxx
24773                                                         cpyewtrn.  */
24774                                                      return 3141;
24775                                                    }
24776                                                }
24777                                            }
24778                                          else
24779                                            {
24780                                              if (((word >> 15) & 0x1) == 0)
24781                                                {
24782                                                  if (((word >> 23) & 0x1) == 0)
24783                                                    {
24784                                                      /* 33222222222211111111110000000000
24785                                                         10987654321098765432109876543210
24786                                                         xx01110100xxxxxx0101x1xxxxxxxxxx
24787                                                         cpypwtwn.  */
24788                                                      return 3136;
24789                                                    }
24790                                                  else
24791                                                    {
24792                                                      /* 33222222222211111111110000000000
24793                                                         10987654321098765432109876543210
24794                                                         xx01110110xxxxxx0101x1xxxxxxxxxx
24795                                                         cpyewtwn.  */
24796                                                      return 3138;
24797                                                    }
24798                                                }
24799                                              else
24800                                                {
24801                                                  if (((word >> 23) & 0x1) == 0)
24802                                                    {
24803                                                      /* 33222222222211111111110000000000
24804                                                         10987654321098765432109876543210
24805                                                         xx01110100xxxxxx1101x1xxxxxxxxxx
24806                                                         cpypwtn.  */
24807                                                      return 3142;
24808                                                    }
24809                                                  else
24810                                                    {
24811                                                      /* 33222222222211111111110000000000
24812                                                         10987654321098765432109876543210
24813                                                         xx01110110xxxxxx1101x1xxxxxxxxxx
24814                                                         cpyewtn.  */
24815                                                      return 3144;
24816                                                    }
24817                                                }
24818                                            }
24819                                        }
24820                                      else
24821                                        {
24822                                          if (((word >> 14) & 0x1) == 0)
24823                                            {
24824                                              if (((word >> 15) & 0x1) == 0)
24825                                                {
24826                                                  if (((word >> 23) & 0x1) == 0)
24827                                                    {
24828                                                      /* 33222222222211111111110000000000
24829                                                         10987654321098765432109876543210
24830                                                         xx01110100xxxxxx0011x1xxxxxxxxxx
24831                                                         cpypt.  */
24832                                                      return 3157;
24833                                                    }
24834                                                  else
24835                                                    {
24836                                                      /* 33222222222211111111110000000000
24837                                                         10987654321098765432109876543210
24838                                                         xx01110110xxxxxx0011x1xxxxxxxxxx
24839                                                         cpyet.  */
24840                                                      return 3159;
24841                                                    }
24842                                                }
24843                                              else
24844                                                {
24845                                                  if (((word >> 23) & 0x1) == 0)
24846                                                    {
24847                                                      /* 33222222222211111111110000000000
24848                                                         10987654321098765432109876543210
24849                                                         xx01110100xxxxxx1011x1xxxxxxxxxx
24850                                                         cpyptrn.  */
24851                                                      return 3163;
24852                                                    }
24853                                                  else
24854                                                    {
24855                                                      /* 33222222222211111111110000000000
24856                                                         10987654321098765432109876543210
24857                                                         xx01110110xxxxxx1011x1xxxxxxxxxx
24858                                                         cpyetrn.  */
24859                                                      return 3165;
24860                                                    }
24861                                                }
24862                                            }
24863                                          else
24864                                            {
24865                                              if (((word >> 15) & 0x1) == 0)
24866                                                {
24867                                                  if (((word >> 23) & 0x1) == 0)
24868                                                    {
24869                                                      /* 33222222222211111111110000000000
24870                                                         10987654321098765432109876543210
24871                                                         xx01110100xxxxxx0111x1xxxxxxxxxx
24872                                                         cpyptwn.  */
24873                                                      return 3160;
24874                                                    }
24875                                                  else
24876                                                    {
24877                                                      /* 33222222222211111111110000000000
24878                                                         10987654321098765432109876543210
24879                                                         xx01110110xxxxxx0111x1xxxxxxxxxx
24880                                                         cpyetwn.  */
24881                                                      return 3162;
24882                                                    }
24883                                                }
24884                                              else
24885                                                {
24886                                                  if (((word >> 23) & 0x1) == 0)
24887                                                    {
24888                                                      /* 33222222222211111111110000000000
24889                                                         10987654321098765432109876543210
24890                                                         xx01110100xxxxxx1111x1xxxxxxxxxx
24891                                                         cpyptn.  */
24892                                                      return 3166;
24893                                                    }
24894                                                  else
24895                                                    {
24896                                                      /* 33222222222211111111110000000000
24897                                                         10987654321098765432109876543210
24898                                                         xx01110110xxxxxx1111x1xxxxxxxxxx
24899                                                         cpyetn.  */
24900                                                      return 3168;
24901                                                    }
24902                                                }
24903                                            }
24904                                        }
24905                                    }
24906                                }
24907                            }
24908                          else
24909                            {
24910                              /* 33222222222211111111110000000000
24911                                 10987654321098765432109876543210
24912                                 xx111101x0xxxxxxxxxxxxxxxxxxxxxx
24913                                 str.  */
24914                              return 892;
24915                            }
24916                        }
24917                      else
24918                        {
24919                          if (((word >> 29) & 0x1) == 0)
24920                            {
24921                              if (((word >> 10) & 0x1) == 0)
24922                                {
24923                                  /* 33222222222211111111110000000000
24924                                     10987654321098765432109876543210
24925                                     xx011101x1xxxxxxxxxxx0xxxxxxxxxx
24926                                     ldapur.  */
24927                                  return 1204;
24928                                }
24929                              else
24930                                {
24931                                  if (((word >> 12) & 0x1) == 0)
24932                                    {
24933                                      if (((word >> 13) & 0x1) == 0)
24934                                        {
24935                                          if (((word >> 14) & 0x1) == 0)
24936                                            {
24937                                              if (((word >> 15) & 0x1) == 0)
24938                                                {
24939                                                  if (((word >> 23) & 0x1) == 0)
24940                                                    {
24941                                                      /* 33222222222211111111110000000000
24942                                                         10987654321098765432109876543210
24943                                                         xx01110101xxxxxx0000x1xxxxxxxxxx
24944                                                         cpym.  */
24945                                                      return 3122;
24946                                                    }
24947                                                  else
24948                                                    {
24949                                                      /* 33222222222211111111110000000000
24950                                                         10987654321098765432109876543210
24951                                                         xx01110111xxxxxx0000x1xxxxxxxxxx
24952                                                         setgp.  */
24953                                                      return 3181;
24954                                                    }
24955                                                }
24956                                              else
24957                                                {
24958                                                  if (((word >> 23) & 0x1) == 0)
24959                                                    {
24960                                                      /* 33222222222211111111110000000000
24961                                                         10987654321098765432109876543210
24962                                                         xx01110101xxxxxx1000x1xxxxxxxxxx
24963                                                         cpymrn.  */
24964                                                      return 3128;
24965                                                    }
24966                                                  else
24967                                                    {
24968                                                      /* 33222222222211111111110000000000
24969                                                         10987654321098765432109876543210
24970                                                         xx01110111xxxxxx1000x1xxxxxxxxxx
24971                                                         setge.  */
24972                                                      return 3183;
24973                                                    }
24974                                                }
24975                                            }
24976                                          else
24977                                            {
24978                                              if (((word >> 15) & 0x1) == 0)
24979                                                {
24980                                                  if (((word >> 23) & 0x1) == 0)
24981                                                    {
24982                                                      /* 33222222222211111111110000000000
24983                                                         10987654321098765432109876543210
24984                                                         xx01110101xxxxxx0100x1xxxxxxxxxx
24985                                                         cpymwn.  */
24986                                                      return 3125;
24987                                                    }
24988                                                  else
24989                                                    {
24990                                                      /* 33222222222211111111110000000000
24991                                                         10987654321098765432109876543210
24992                                                         xx01110111xxxxxx0100x1xxxxxxxxxx
24993                                                         setgm.  */
24994                                                      return 3182;
24995                                                    }
24996                                                }
24997                                              else
24998                                                {
24999                                                  /* 33222222222211111111110000000000
25000                                                     10987654321098765432109876543210
25001                                                     xx011101x1xxxxxx1100x1xxxxxxxxxx
25002                                                     cpymn.  */
25003                                                  return 3131;
25004                                                }
25005                                            }
25006                                        }
25007                                      else
25008                                        {
25009                                          if (((word >> 14) & 0x1) == 0)
25010                                            {
25011                                              if (((word >> 15) & 0x1) == 0)
25012                                                {
25013                                                  if (((word >> 23) & 0x1) == 0)
25014                                                    {
25015                                                      /* 33222222222211111111110000000000
25016                                                         10987654321098765432109876543210
25017                                                         xx01110101xxxxxx0010x1xxxxxxxxxx
25018                                                         cpymrt.  */
25019                                                      return 3146;
25020                                                    }
25021                                                  else
25022                                                    {
25023                                                      /* 33222222222211111111110000000000
25024                                                         10987654321098765432109876543210
25025                                                         xx01110111xxxxxx0010x1xxxxxxxxxx
25026                                                         setgpn.  */
25027                                                      return 3187;
25028                                                    }
25029                                                }
25030                                              else
25031                                                {
25032                                                  if (((word >> 23) & 0x1) == 0)
25033                                                    {
25034                                                      /* 33222222222211111111110000000000
25035                                                         10987654321098765432109876543210
25036                                                         xx01110101xxxxxx1010x1xxxxxxxxxx
25037                                                         cpymrtrn.  */
25038                                                      return 3152;
25039                                                    }
25040                                                  else
25041                                                    {
25042                                                      /* 33222222222211111111110000000000
25043                                                         10987654321098765432109876543210
25044                                                         xx01110111xxxxxx1010x1xxxxxxxxxx
25045                                                         setgen.  */
25046                                                      return 3189;
25047                                                    }
25048                                                }
25049                                            }
25050                                          else
25051                                            {
25052                                              if (((word >> 15) & 0x1) == 0)
25053                                                {
25054                                                  if (((word >> 23) & 0x1) == 0)
25055                                                    {
25056                                                      /* 33222222222211111111110000000000
25057                                                         10987654321098765432109876543210
25058                                                         xx01110101xxxxxx0110x1xxxxxxxxxx
25059                                                         cpymrtwn.  */
25060                                                      return 3149;
25061                                                    }
25062                                                  else
25063                                                    {
25064                                                      /* 33222222222211111111110000000000
25065                                                         10987654321098765432109876543210
25066                                                         xx01110111xxxxxx0110x1xxxxxxxxxx
25067                                                         setgmn.  */
25068                                                      return 3188;
25069                                                    }
25070                                                }
25071                                              else
25072                                                {
25073                                                  /* 33222222222211111111110000000000
25074                                                     10987654321098765432109876543210
25075                                                     xx011101x1xxxxxx1110x1xxxxxxxxxx
25076                                                     cpymrtn.  */
25077                                                  return 3155;
25078                                                }
25079                                            }
25080                                        }
25081                                    }
25082                                  else
25083                                    {
25084                                      if (((word >> 13) & 0x1) == 0)
25085                                        {
25086                                          if (((word >> 14) & 0x1) == 0)
25087                                            {
25088                                              if (((word >> 15) & 0x1) == 0)
25089                                                {
25090                                                  if (((word >> 23) & 0x1) == 0)
25091                                                    {
25092                                                      /* 33222222222211111111110000000000
25093                                                         10987654321098765432109876543210
25094                                                         xx01110101xxxxxx0001x1xxxxxxxxxx
25095                                                         cpymwt.  */
25096                                                      return 3134;
25097                                                    }
25098                                                  else
25099                                                    {
25100                                                      /* 33222222222211111111110000000000
25101                                                         10987654321098765432109876543210
25102                                                         xx01110111xxxxxx0001x1xxxxxxxxxx
25103                                                         setgpt.  */
25104                                                      return 3184;
25105                                                    }
25106                                                }
25107                                              else
25108                                                {
25109                                                  if (((word >> 23) & 0x1) == 0)
25110                                                    {
25111                                                      /* 33222222222211111111110000000000
25112                                                         10987654321098765432109876543210
25113                                                         xx01110101xxxxxx1001x1xxxxxxxxxx
25114                                                         cpymwtrn.  */
25115                                                      return 3140;
25116                                                    }
25117                                                  else
25118                                                    {
25119                                                      /* 33222222222211111111110000000000
25120                                                         10987654321098765432109876543210
25121                                                         xx01110111xxxxxx1001x1xxxxxxxxxx
25122                                                         setget.  */
25123                                                      return 3186;
25124                                                    }
25125                                                }
25126                                            }
25127                                          else
25128                                            {
25129                                              if (((word >> 15) & 0x1) == 0)
25130                                                {
25131                                                  if (((word >> 23) & 0x1) == 0)
25132                                                    {
25133                                                      /* 33222222222211111111110000000000
25134                                                         10987654321098765432109876543210
25135                                                         xx01110101xxxxxx0101x1xxxxxxxxxx
25136                                                         cpymwtwn.  */
25137                                                      return 3137;
25138                                                    }
25139                                                  else
25140                                                    {
25141                                                      /* 33222222222211111111110000000000
25142                                                         10987654321098765432109876543210
25143                                                         xx01110111xxxxxx0101x1xxxxxxxxxx
25144                                                         setgmt.  */
25145                                                      return 3185;
25146                                                    }
25147                                                }
25148                                              else
25149                                                {
25150                                                  /* 33222222222211111111110000000000
25151                                                     10987654321098765432109876543210
25152                                                     xx011101x1xxxxxx1101x1xxxxxxxxxx
25153                                                     cpymwtn.  */
25154                                                  return 3143;
25155                                                }
25156                                            }
25157                                        }
25158                                      else
25159                                        {
25160                                          if (((word >> 14) & 0x1) == 0)
25161                                            {
25162                                              if (((word >> 15) & 0x1) == 0)
25163                                                {
25164                                                  if (((word >> 23) & 0x1) == 0)
25165                                                    {
25166                                                      /* 33222222222211111111110000000000
25167                                                         10987654321098765432109876543210
25168                                                         xx01110101xxxxxx0011x1xxxxxxxxxx
25169                                                         cpymt.  */
25170                                                      return 3158;
25171                                                    }
25172                                                  else
25173                                                    {
25174                                                      /* 33222222222211111111110000000000
25175                                                         10987654321098765432109876543210
25176                                                         xx01110111xxxxxx0011x1xxxxxxxxxx
25177                                                         setgptn.  */
25178                                                      return 3190;
25179                                                    }
25180                                                }
25181                                              else
25182                                                {
25183                                                  if (((word >> 23) & 0x1) == 0)
25184                                                    {
25185                                                      /* 33222222222211111111110000000000
25186                                                         10987654321098765432109876543210
25187                                                         xx01110101xxxxxx1011x1xxxxxxxxxx
25188                                                         cpymtrn.  */
25189                                                      return 3164;
25190                                                    }
25191                                                  else
25192                                                    {
25193                                                      /* 33222222222211111111110000000000
25194                                                         10987654321098765432109876543210
25195                                                         xx01110111xxxxxx1011x1xxxxxxxxxx
25196                                                         setgetn.  */
25197                                                      return 3192;
25198                                                    }
25199                                                }
25200                                            }
25201                                          else
25202                                            {
25203                                              if (((word >> 15) & 0x1) == 0)
25204                                                {
25205                                                  if (((word >> 23) & 0x1) == 0)
25206                                                    {
25207                                                      /* 33222222222211111111110000000000
25208                                                         10987654321098765432109876543210
25209                                                         xx01110101xxxxxx0111x1xxxxxxxxxx
25210                                                         cpymtwn.  */
25211                                                      return 3161;
25212                                                    }
25213                                                  else
25214                                                    {
25215                                                      /* 33222222222211111111110000000000
25216                                                         10987654321098765432109876543210
25217                                                         xx01110111xxxxxx0111x1xxxxxxxxxx
25218                                                         setgmtn.  */
25219                                                      return 3191;
25220                                                    }
25221                                                }
25222                                              else
25223                                                {
25224                                                  /* 33222222222211111111110000000000
25225                                                     10987654321098765432109876543210
25226                                                     xx011101x1xxxxxx1111x1xxxxxxxxxx
25227                                                     cpymtn.  */
25228                                                  return 3167;
25229                                                }
25230                                            }
25231                                        }
25232                                    }
25233                                }
25234                            }
25235                          else
25236                            {
25237                              /* 33222222222211111111110000000000
25238                                 10987654321098765432109876543210
25239                                 xx111101x1xxxxxxxxxxxxxxxxxxxxxx
25240                                 ldr.  */
25241                              return 893;
25242                            }
25243                        }
25244                    }
25245                }
25246            }
25247          else
25248            {
25249              if (((word >> 24) & 0x1) == 0)
25250                {
25251                  if (((word >> 21) & 0x1) == 0)
25252                    {
25253                      if (((word >> 28) & 0x1) == 0)
25254                        {
25255                          if (((word >> 29) & 0x1) == 0)
25256                            {
25257                              if (((word >> 31) & 0x1) == 0)
25258                                {
25259                                  if (((word >> 10) & 0x1) == 0)
25260                                    {
25261                                      if (((word >> 11) & 0x1) == 0)
25262                                        {
25263                                          if (((word >> 12) & 0x1) == 0)
25264                                            {
25265                                              /* 33222222222211111111110000000000
25266                                                 10987654321098765432109876543210
25267                                                 0x001110xx0xxxxxxxx000xxxxxxxxxx
25268                                                 tbl.  */
25269                                              return 420;
25270                                            }
25271                                          else
25272                                            {
25273                                              /* 33222222222211111111110000000000
25274                                                 10987654321098765432109876543210
25275                                                 0x001110xx0xxxxxxxx100xxxxxxxxxx
25276                                                 tbx.  */
25277                                              return 421;
25278                                            }
25279                                        }
25280                                      else
25281                                        {
25282                                          if (((word >> 12) & 0x1) == 0)
25283                                            {
25284                                              if (((word >> 14) & 0x1) == 0)
25285                                                {
25286                                                  /* 33222222222211111111110000000000
25287                                                     10987654321098765432109876543210
25288                                                     0x001110xx0xxxxxx0x010xxxxxxxxxx
25289                                                     trn1.  */
25290                                                  return 263;
25291                                                }
25292                                              else
25293                                                {
25294                                                  /* 33222222222211111111110000000000
25295                                                     10987654321098765432109876543210
25296                                                     0x001110xx0xxxxxx1x010xxxxxxxxxx
25297                                                     trn2.  */
25298                                                  return 266;
25299                                                }
25300                                            }
25301                                          else
25302                                            {
25303                                              if (((word >> 13) & 0x1) == 0)
25304                                                {
25305                                                  if (((word >> 14) & 0x1) == 0)
25306                                                    {
25307                                                      /* 33222222222211111111110000000000
25308                                                         10987654321098765432109876543210
25309                                                         0x001110xx0xxxxxx00110xxxxxxxxxx
25310                                                         uzp1.  */
25311                                                      return 262;
25312                                                    }
25313                                                  else
25314                                                    {
25315                                                      /* 33222222222211111111110000000000
25316                                                         10987654321098765432109876543210
25317                                                         0x001110xx0xxxxxx10110xxxxxxxxxx
25318                                                         uzp2.  */
25319                                                      return 265;
25320                                                    }
25321                                                }
25322                                              else
25323                                                {
25324                                                  if (((word >> 14) & 0x1) == 0)
25325                                                    {
25326                                                      /* 33222222222211111111110000000000
25327                                                         10987654321098765432109876543210
25328                                                         0x001110xx0xxxxxx01110xxxxxxxxxx
25329                                                         zip1.  */
25330                                                      return 264;
25331                                                    }
25332                                                  else
25333                                                    {
25334                                                      /* 33222222222211111111110000000000
25335                                                         10987654321098765432109876543210
25336                                                         0x001110xx0xxxxxx11110xxxxxxxxxx
25337                                                         zip2.  */
25338                                                      return 267;
25339                                                    }
25340                                                }
25341                                            }
25342                                        }
25343                                    }
25344                                  else
25345                                    {
25346                                      if (((word >> 11) & 0x1) == 0)
25347                                        {
25348                                          if (((word >> 12) & 0x1) == 0)
25349                                            {
25350                                              if (((word >> 13) & 0x1) == 0)
25351                                                {
25352                                                  if (((word >> 22) & 0x1) == 0)
25353                                                    {
25354                                                      /* 33222222222211111111110000000000
25355                                                         10987654321098765432109876543210
25356                                                         0x001110x00xxxxxxx0001xxxxxxxxxx
25357                                                         dup.  */
25358                                                      return 149;
25359                                                    }
25360                                                  else
25361                                                    {
25362                                                      if (((word >> 23) & 0x1) == 0)
25363                                                        {
25364                                                          /* 33222222222211111111110000000000
25365                                                             10987654321098765432109876543210
25366                                                             0x001110010xxxxxxx0001xxxxxxxxxx
25367                                                             fmaxnm.  */
25368                                                          return 292;
25369                                                        }
25370                                                      else
25371                                                        {
25372                                                          /* 33222222222211111111110000000000
25373                                                             10987654321098765432109876543210
25374                                                             0x001110110xxxxxxx0001xxxxxxxxxx
25375                                                             fminnm.  */
25376                                                          return 308;
25377                                                        }
25378                                                    }
25379                                                }
25380                                              else
25381                                                {
25382                                                  if (((word >> 15) & 0x1) == 0)
25383                                                    {
25384                                                      /* 33222222222211111111110000000000
25385                                                         10987654321098765432109876543210
25386                                                         0x001110xx0xxxxx0x1001xxxxxxxxxx
25387                                                         fcmeq.  */
25388                                                      return 300;
25389                                                    }
25390                                                  else
25391                                                    {
25392                                                      /* 33222222222211111111110000000000
25393                                                         10987654321098765432109876543210
25394                                                         0x001110xx0xxxxx1x1001xxxxxxxxxx
25395                                                         smmla.  */
25396                                                      return 3048;
25397                                                    }
25398                                                }
25399                                            }
25400                                          else
25401                                            {
25402                                              if (((word >> 13) & 0x1) == 0)
25403                                                {
25404                                                  if (((word >> 15) & 0x1) == 0)
25405                                                    {
25406                                                      if (((word >> 23) & 0x1) == 0)
25407                                                        {
25408                                                          /* 33222222222211111111110000000000
25409                                                             10987654321098765432109876543210
25410                                                             0x0011100x0xxxxx0x0101xxxxxxxxxx
25411                                                             fadd.  */
25412                                                          return 296;
25413                                                        }
25414                                                      else
25415                                                        {
25416                                                          /* 33222222222211111111110000000000
25417                                                             10987654321098765432109876543210
25418                                                             0x0011101x0xxxxx0x0101xxxxxxxxxx
25419                                                             fsub.  */
25420                                                          return 312;
25421                                                        }
25422                                                    }
25423                                                  else
25424                                                    {
25425                                                      /* 33222222222211111111110000000000
25426                                                         10987654321098765432109876543210
25427                                                         0x001110xx0xxxxx1x0101xxxxxxxxxx
25428                                                         sdot.  */
25429                                                      return 2974;
25430                                                    }
25431                                                }
25432                                              else
25433                                                {
25434                                                  if (((word >> 23) & 0x1) == 0)
25435                                                    {
25436                                                      /* 33222222222211111111110000000000
25437                                                         10987654321098765432109876543210
25438                                                         0x0011100x0xxxxxxx1101xxxxxxxxxx
25439                                                         fmax.  */
25440                                                      return 302;
25441                                                    }
25442                                                  else
25443                                                    {
25444                                                      /* 33222222222211111111110000000000
25445                                                         10987654321098765432109876543210
25446                                                         0x0011101x0xxxxxxx1101xxxxxxxxxx
25447                                                         fmin.  */
25448                                                      return 314;
25449                                                    }
25450                                                }
25451                                            }
25452                                        }
25453                                      else
25454                                        {
25455                                          if (((word >> 12) & 0x1) == 0)
25456                                            {
25457                                              if (((word >> 13) & 0x1) == 0)
25458                                                {
25459                                                  if (((word >> 22) & 0x1) == 0)
25460                                                    {
25461                                                      /* 33222222222211111111110000000000
25462                                                         10987654321098765432109876543210
25463                                                         0x001110x00xxxxxxx0011xxxxxxxxxx
25464                                                         dup.  */
25465                                                      return 150;
25466                                                    }
25467                                                  else
25468                                                    {
25469                                                      if (((word >> 23) & 0x1) == 0)
25470                                                        {
25471                                                          /* 33222222222211111111110000000000
25472                                                             10987654321098765432109876543210
25473                                                             0x001110010xxxxxxx0011xxxxxxxxxx
25474                                                             fmla.  */
25475                                                          return 294;
25476                                                        }
25477                                                      else
25478                                                        {
25479                                                          /* 33222222222211111111110000000000
25480                                                             10987654321098765432109876543210
25481                                                             0x001110110xxxxxxx0011xxxxxxxxxx
25482                                                             fmls.  */
25483                                                          return 310;
25484                                                        }
25485                                                    }
25486                                                }
25487                                              else
25488                                                {
25489                                                  if (((word >> 15) & 0x1) == 0)
25490                                                    {
25491                                                      /* 33222222222211111111110000000000
25492                                                         10987654321098765432109876543210
25493                                                         0x001110xx0xxxxx0x1011xxxxxxxxxx
25494                                                         smov.  */
25495                                                      return 151;
25496                                                    }
25497                                                  else
25498                                                    {
25499                                                      /* 33222222222211111111110000000000
25500                                                         10987654321098765432109876543210
25501                                                         0x001110xx0xxxxx1x1011xxxxxxxxxx
25502                                                         usmmla.  */
25503                                                      return 3050;
25504                                                    }
25505                                                }
25506                                            }
25507                                          else
25508                                            {
25509                                              if (((word >> 13) & 0x1) == 0)
25510                                                {
25511                                                  if (((word >> 15) & 0x1) == 0)
25512                                                    {
25513                                                      if (((word >> 22) & 0x1) == 0)
25514                                                        {
25515                                                          /* 33222222222211111111110000000000
25516                                                             10987654321098765432109876543210
25517                                                             0x001110x00xxxxx0x0111xxxxxxxxxx
25518                                                             ins.  */
25519                                                          return 154;
25520                                                        }
25521                                                      else
25522                                                        {
25523                                                          /* 33222222222211111111110000000000
25524                                                             10987654321098765432109876543210
25525                                                             0x001110x10xxxxx0x0111xxxxxxxxxx
25526                                                             fmulx.  */
25527                                                          return 298;
25528                                                        }
25529                                                    }
25530                                                  else
25531                                                    {
25532                                                      /* 33222222222211111111110000000000
25533                                                         10987654321098765432109876543210
25534                                                         0x001110xx0xxxxx1x0111xxxxxxxxxx
25535                                                         usdot.  */
25536                                                      return 3051;
25537                                                    }
25538                                                }
25539                                              else
25540                                                {
25541                                                  if (((word >> 22) & 0x1) == 0)
25542                                                    {
25543                                                      /* 33222222222211111111110000000000
25544                                                         10987654321098765432109876543210
25545                                                         0x001110x00xxxxxxx1111xxxxxxxxxx
25546                                                         umov.  */
25547                                                      return 152;
25548                                                    }
25549                                                  else
25550                                                    {
25551                                                      if (((word >> 23) & 0x1) == 0)
25552                                                        {
25553                                                          /* 33222222222211111111110000000000
25554                                                             10987654321098765432109876543210
25555                                                             0x001110010xxxxxxx1111xxxxxxxxxx
25556                                                             frecps.  */
25557                                                          return 304;
25558                                                        }
25559                                                      else
25560                                                        {
25561                                                          /* 33222222222211111111110000000000
25562                                                             10987654321098765432109876543210
25563                                                             0x001110110xxxxxxx1111xxxxxxxxxx
25564                                                             frsqrts.  */
25565                                                          return 316;
25566                                                        }
25567                                                    }
25568                                                }
25569                                            }
25570                                        }
25571                                    }
25572                                }
25573                              else
25574                                {
25575                                  if (((word >> 22) & 0x1) == 0)
25576                                    {
25577                                      if (((word >> 23) & 0x1) == 0)
25578                                        {
25579                                          /* 33222222222211111111110000000000
25580                                             10987654321098765432109876543210
25581                                             1x001110000xxxxxxxxxxxxxxxxxxxxx
25582                                             eor3.  */
25583                                          return 2981;
25584                                        }
25585                                      else
25586                                        {
25587                                          /* 33222222222211111111110000000000
25588                                             10987654321098765432109876543210
25589                                             1x001110100xxxxxxxxxxxxxxxxxxxxx
25590                                             xar.  */
25591                                          return 2983;
25592                                        }
25593                                    }
25594                                  else
25595                                    {
25596                                      if (((word >> 15) & 0x1) == 0)
25597                                        {
25598                                          /* 33222222222211111111110000000000
25599                                             10987654321098765432109876543210
25600                                             1x001110x10xxxxx0xxxxxxxxxxxxxxx
25601                                             sm3ss1.  */
25602                                          return 2985;
25603                                        }
25604                                      else
25605                                        {
25606                                          if (((word >> 10) & 0x1) == 0)
25607                                            {
25608                                              if (((word >> 11) & 0x1) == 0)
25609                                                {
25610                                                  if (((word >> 23) & 0x1) == 0)
25611                                                    {
25612                                                      /* 33222222222211111111110000000000
25613                                                         10987654321098765432109876543210
25614                                                         1x001110010xxxxx1xxx00xxxxxxxxxx
25615                                                         sm3tt1a.  */
25616                                                      return 2986;
25617                                                    }
25618                                                  else
25619                                                    {
25620                                                      /* 33222222222211111111110000000000
25621                                                         10987654321098765432109876543210
25622                                                         1x001110110xxxxx1xxx00xxxxxxxxxx
25623                                                         sha512su0.  */
25624                                                      return 2979;
25625                                                    }
25626                                                }
25627                                              else
25628                                                {
25629                                                  /* 33222222222211111111110000000000
25630                                                     10987654321098765432109876543210
25631                                                     1x001110x10xxxxx1xxx10xxxxxxxxxx
25632                                                     sm3tt2a.  */
25633                                                  return 2988;
25634                                                }
25635                                            }
25636                                          else
25637                                            {
25638                                              if (((word >> 11) & 0x1) == 0)
25639                                                {
25640                                                  if (((word >> 23) & 0x1) == 0)
25641                                                    {
25642                                                      /* 33222222222211111111110000000000
25643                                                         10987654321098765432109876543210
25644                                                         1x001110010xxxxx1xxx01xxxxxxxxxx
25645                                                         sm3tt1b.  */
25646                                                      return 2987;
25647                                                    }
25648                                                  else
25649                                                    {
25650                                                      /* 33222222222211111111110000000000
25651                                                         10987654321098765432109876543210
25652                                                         1x001110110xxxxx1xxx01xxxxxxxxxx
25653                                                         sm4e.  */
25654                                                      return 2992;
25655                                                    }
25656                                                }
25657                                              else
25658                                                {
25659                                                  /* 33222222222211111111110000000000
25660                                                     10987654321098765432109876543210
25661                                                     1x001110x10xxxxx1xxx11xxxxxxxxxx
25662                                                     sm3tt2b.  */
25663                                                  return 2989;
25664                                                }
25665                                            }
25666                                        }
25667                                    }
25668                                }
25669                            }
25670                          else
25671                            {
25672                              if (((word >> 10) & 0x1) == 0)
25673                                {
25674                                  /* 33222222222211111111110000000000
25675                                     10987654321098765432109876543210
25676                                     xx101110xx0xxxxxxxxxx0xxxxxxxxxx
25677                                     ext.  */
25678                                  return 132;
25679                                }
25680                              else
25681                                {
25682                                  if (((word >> 15) & 0x1) == 0)
25683                                    {
25684                                      if (((word >> 22) & 0x1) == 0)
25685                                        {
25686                                          /* 33222222222211111111110000000000
25687                                             10987654321098765432109876543210
25688                                             xx101110x00xxxxx0xxxx1xxxxxxxxxx
25689                                             ins.  */
25690                                          return 156;
25691                                        }
25692                                      else
25693                                        {
25694                                          if (((word >> 11) & 0x1) == 0)
25695                                            {
25696                                              if (((word >> 12) & 0x1) == 0)
25697                                                {
25698                                                  if (((word >> 13) & 0x1) == 0)
25699                                                    {
25700                                                      if (((word >> 23) & 0x1) == 0)
25701                                                        {
25702                                                          /* 33222222222211111111110000000000
25703                                                             10987654321098765432109876543210
25704                                                             xx101110010xxxxx0x0001xxxxxxxxxx
25705                                                             fmaxnmp.  */
25706                                                          return 343;
25707                                                        }
25708                                                      else
25709                                                        {
25710                                                          /* 33222222222211111111110000000000
25711                                                             10987654321098765432109876543210
25712                                                             xx101110110xxxxx0x0001xxxxxxxxxx
25713                                                             fminnmp.  */
25714                                                          return 359;
25715                                                        }
25716                                                    }
25717                                                  else
25718                                                    {
25719                                                      if (((word >> 23) & 0x1) == 0)
25720                                                        {
25721                                                          /* 33222222222211111111110000000000
25722                                                             10987654321098765432109876543210
25723                                                             xx101110010xxxxx0x1001xxxxxxxxxx
25724                                                             fcmge.  */
25725                                                          return 349;
25726                                                        }
25727                                                      else
25728                                                        {
25729                                                          /* 33222222222211111111110000000000
25730                                                             10987654321098765432109876543210
25731                                                             xx101110110xxxxx0x1001xxxxxxxxxx
25732                                                             fcmgt.  */
25733                                                          return 363;
25734                                                        }
25735                                                    }
25736                                                }
25737                                              else
25738                                                {
25739                                                  if (((word >> 13) & 0x1) == 0)
25740                                                    {
25741                                                      if (((word >> 23) & 0x1) == 0)
25742                                                        {
25743                                                          /* 33222222222211111111110000000000
25744                                                             10987654321098765432109876543210
25745                                                             xx101110010xxxxx0x0101xxxxxxxxxx
25746                                                             faddp.  */
25747                                                          return 345;
25748                                                        }
25749                                                      else
25750                                                        {
25751                                                          /* 33222222222211111111110000000000
25752                                                             10987654321098765432109876543210
25753                                                             xx101110110xxxxx0x0101xxxxxxxxxx
25754                                                             fabd.  */
25755                                                          return 361;
25756                                                        }
25757                                                    }
25758                                                  else
25759                                                    {
25760                                                      if (((word >> 23) & 0x1) == 0)
25761                                                        {
25762                                                          /* 33222222222211111111110000000000
25763                                                             10987654321098765432109876543210
25764                                                             xx101110010xxxxx0x1101xxxxxxxxxx
25765                                                             fmaxp.  */
25766                                                          return 353;
25767                                                        }
25768                                                      else
25769                                                        {
25770                                                          /* 33222222222211111111110000000000
25771                                                             10987654321098765432109876543210
25772                                                             xx101110110xxxxx0x1101xxxxxxxxxx
25773                                                             fminp.  */
25774                                                          return 367;
25775                                                        }
25776                                                    }
25777                                                }
25778                                            }
25779                                          else
25780                                            {
25781                                              if (((word >> 12) & 0x1) == 0)
25782                                                {
25783                                                  if (((word >> 23) & 0x1) == 0)
25784                                                    {
25785                                                      /* 33222222222211111111110000000000
25786                                                         10987654321098765432109876543210
25787                                                         xx101110010xxxxx0xx011xxxxxxxxxx
25788                                                         facge.  */
25789                                                      return 351;
25790                                                    }
25791                                                  else
25792                                                    {
25793                                                      /* 33222222222211111111110000000000
25794                                                         10987654321098765432109876543210
25795                                                         xx101110110xxxxx0xx011xxxxxxxxxx
25796                                                         facgt.  */
25797                                                      return 365;
25798                                                    }
25799                                                }
25800                                              else
25801                                                {
25802                                                  if (((word >> 13) & 0x1) == 0)
25803                                                    {
25804                                                      /* 33222222222211111111110000000000
25805                                                         10987654321098765432109876543210
25806                                                         xx101110x10xxxxx0x0111xxxxxxxxxx
25807                                                         fmul.  */
25808                                                      return 347;
25809                                                    }
25810                                                  else
25811                                                    {
25812                                                      /* 33222222222211111111110000000000
25813                                                         10987654321098765432109876543210
25814                                                         xx101110x10xxxxx0x1111xxxxxxxxxx
25815                                                         fdiv.  */
25816                                                      return 355;
25817                                                    }
25818                                                }
25819                                            }
25820                                        }
25821                                    }
25822                                  else
25823                                    {
25824                                      if (((word >> 13) & 0x1) == 0)
25825                                        {
25826                                          if (((word >> 14) & 0x1) == 0)
25827                                            {
25828                                              if (((word >> 11) & 0x1) == 0)
25829                                                {
25830                                                  if (((word >> 12) & 0x1) == 0)
25831                                                    {
25832                                                      /* 33222222222211111111110000000000
25833                                                         10987654321098765432109876543210
25834                                                         xx101110xx0xxxxx100001xxxxxxxxxx
25835                                                         sqrdmlah.  */
25836                                                      return 370;
25837                                                    }
25838                                                  else
25839                                                    {
25840                                                      /* 33222222222211111111110000000000
25841                                                         10987654321098765432109876543210
25842                                                         xx101110xx0xxxxx100101xxxxxxxxxx
25843                                                         udot.  */
25844                                                      return 2973;
25845                                                    }
25846                                                }
25847                                              else
25848                                                {
25849                                                  /* 33222222222211111111110000000000
25850                                                     10987654321098765432109876543210
25851                                                     xx101110xx0xxxxx100x11xxxxxxxxxx
25852                                                     sqrdmlsh.  */
25853                                                  return 371;
25854                                                }
25855                                            }
25856                                          else
25857                                            {
25858                                              /* 33222222222211111111110000000000
25859                                                 10987654321098765432109876543210
25860                                                 xx101110xx0xxxxx110xx1xxxxxxxxxx
25861                                                 fcmla.  */
25862                                              return 372;
25863                                            }
25864                                        }
25865                                      else
25866                                        {
25867                                          if (((word >> 11) & 0x1) == 0)
25868                                            {
25869                                              if (((word >> 14) & 0x1) == 0)
25870                                                {
25871                                                  /* 33222222222211111111110000000000
25872                                                     10987654321098765432109876543210
25873                                                     xx101110xx0xxxxx101x01xxxxxxxxxx
25874                                                     ummla.  */
25875                                                  return 3049;
25876                                                }
25877                                              else
25878                                                {
25879                                                  /* 33222222222211111111110000000000
25880                                                     10987654321098765432109876543210
25881                                                     xx101110xx0xxxxx111x01xxxxxxxxxx
25882                                                     fcadd.  */
25883                                                  return 373;
25884                                                }
25885                                            }
25886                                          else
25887                                            {
25888                                              if (((word >> 12) & 0x1) == 0)
25889                                                {
25890                                                  /* 33222222222211111111110000000000
25891                                                     10987654321098765432109876543210
25892                                                     xx101110xx0xxxxx1x1011xxxxxxxxxx
25893                                                     bfmmla.  */
25894                                                  return 3065;
25895                                                }
25896                                              else
25897                                                {
25898                                                  if (((word >> 23) & 0x1) == 0)
25899                                                    {
25900                                                      /* 33222222222211111111110000000000
25901                                                         10987654321098765432109876543210
25902                                                         xx1011100x0xxxxx1x1111xxxxxxxxxx
25903                                                         bfdot.  */
25904                                                      return 3063;
25905                                                    }
25906                                                  else
25907                                                    {
25908                                                      if (((word >> 30) & 0x1) == 0)
25909                                                        {
25910                                                          /* 33222222222211111111110000000000
25911                                                             10987654321098765432109876543210
25912                                                             x01011101x0xxxxx1x1111xxxxxxxxxx
25913                                                             bfmlalb.  */
25914                                                          return 3070;
25915                                                        }
25916                                                      else
25917                                                        {
25918                                                          /* 33222222222211111111110000000000
25919                                                             10987654321098765432109876543210
25920                                                             x11011101x0xxxxx1x1111xxxxxxxxxx
25921                                                             bfmlalt.  */
25922                                                          return 3069;
25923                                                        }
25924                                                    }
25925                                                }
25926                                            }
25927                                        }
25928                                    }
25929                                }
25930                            }
25931                        }
25932                      else
25933                        {
25934                          if (((word >> 29) & 0x1) == 0)
25935                            {
25936                              if (((word >> 30) & 0x1) == 0)
25937                                {
25938                                  if (((word >> 16) & 0x1) == 0)
25939                                    {
25940                                      if (((word >> 17) & 0x1) == 0)
25941                                        {
25942                                          /* 33222222222211111111110000000000
25943                                             10987654321098765432109876543210
25944                                             x0011110xx0xxx00xxxxxxxxxxxxxxxx
25945                                             fcvtzs.  */
25946                                          return 764;
25947                                        }
25948                                      else
25949                                        {
25950                                          /* 33222222222211111111110000000000
25951                                             10987654321098765432109876543210
25952                                             x0011110xx0xxx10xxxxxxxxxxxxxxxx
25953                                             scvtf.  */
25954                                          return 760;
25955                                        }
25956                                    }
25957                                  else
25958                                    {
25959                                      if (((word >> 17) & 0x1) == 0)
25960                                        {
25961                                          /* 33222222222211111111110000000000
25962                                             10987654321098765432109876543210
25963                                             x0011110xx0xxx01xxxxxxxxxxxxxxxx
25964                                             fcvtzu.  */
25965                                          return 766;
25966                                        }
25967                                      else
25968                                        {
25969                                          /* 33222222222211111111110000000000
25970                                             10987654321098765432109876543210
25971                                             x0011110xx0xxx11xxxxxxxxxxxxxxxx
25972                                             ucvtf.  */
25973                                          return 762;
25974                                        }
25975                                    }
25976                                }
25977                              else
25978                                {
25979                                  if (((word >> 10) & 0x1) == 0)
25980                                    {
25981                                      if (((word >> 12) & 0x1) == 0)
25982                                        {
25983                                          if (((word >> 13) & 0x1) == 0)
25984                                            {
25985                                              if (((word >> 14) & 0x1) == 0)
25986                                                {
25987                                                  /* 33222222222211111111110000000000
25988                                                     10987654321098765432109876543210
25989                                                     x1011110xx0xxxxxx000x0xxxxxxxxxx
25990                                                     sha1c.  */
25991                                                  return 678;
25992                                                }
25993                                              else
25994                                                {
25995                                                  /* 33222222222211111111110000000000
25996                                                     10987654321098765432109876543210
25997                                                     x1011110xx0xxxxxx100x0xxxxxxxxxx
25998                                                     sha256h.  */
25999                                                  return 682;
26000                                                }
26001                                            }
26002                                          else
26003                                            {
26004                                              if (((word >> 14) & 0x1) == 0)
26005                                                {
26006                                                  /* 33222222222211111111110000000000
26007                                                     10987654321098765432109876543210
26008                                                     x1011110xx0xxxxxx010x0xxxxxxxxxx
26009                                                     sha1m.  */
26010                                                  return 680;
26011                                                }
26012                                              else
26013                                                {
26014                                                  /* 33222222222211111111110000000000
26015                                                     10987654321098765432109876543210
26016                                                     x1011110xx0xxxxxx110x0xxxxxxxxxx
26017                                                     sha256su1.  */
26018                                                  return 684;
26019                                                }
26020                                            }
26021                                        }
26022                                      else
26023                                        {
26024                                          if (((word >> 13) & 0x1) == 0)
26025                                            {
26026                                              if (((word >> 14) & 0x1) == 0)
26027                                                {
26028                                                  /* 33222222222211111111110000000000
26029                                                     10987654321098765432109876543210
26030                                                     x1011110xx0xxxxxx001x0xxxxxxxxxx
26031                                                     sha1p.  */
26032                                                  return 679;
26033                                                }
26034                                              else
26035                                                {
26036                                                  /* 33222222222211111111110000000000
26037                                                     10987654321098765432109876543210
26038                                                     x1011110xx0xxxxxx101x0xxxxxxxxxx
26039                                                     sha256h2.  */
26040                                                  return 683;
26041                                                }
26042                                            }
26043                                          else
26044                                            {
26045                                              /* 33222222222211111111110000000000
26046                                                 10987654321098765432109876543210
26047                                                 x1011110xx0xxxxxxx11x0xxxxxxxxxx
26048                                                 sha1su0.  */
26049                                              return 681;
26050                                            }
26051                                        }
26052                                    }
26053                                  else
26054                                    {
26055                                      if (((word >> 11) & 0x1) == 0)
26056                                        {
26057                                          if (((word >> 13) & 0x1) == 0)
26058                                            {
26059                                              /* 33222222222211111111110000000000
26060                                                 10987654321098765432109876543210
26061                                                 x1011110xx0xxxxxxx0x01xxxxxxxxxx
26062                                                 dup.  */
26063                                              return 535;
26064                                            }
26065                                          else
26066                                            {
26067                                              /* 33222222222211111111110000000000
26068                                                 10987654321098765432109876543210
26069                                                 x1011110xx0xxxxxxx1x01xxxxxxxxxx
26070                                                 fcmeq.  */
26071                                              return 556;
26072                                            }
26073                                        }
26074                                      else
26075                                        {
26076                                          if (((word >> 13) & 0x1) == 0)
26077                                            {
26078                                              /* 33222222222211111111110000000000
26079                                                 10987654321098765432109876543210
26080                                                 x1011110xx0xxxxxxx0x11xxxxxxxxxx
26081                                                 fmulx.  */
26082                                              return 554;
26083                                            }
26084                                          else
26085                                            {
26086                                              if (((word >> 23) & 0x1) == 0)
26087                                                {
26088                                                  /* 33222222222211111111110000000000
26089                                                     10987654321098765432109876543210
26090                                                     x10111100x0xxxxxxx1x11xxxxxxxxxx
26091                                                     frecps.  */
26092                                                  return 558;
26093                                                }
26094                                              else
26095                                                {
26096                                                  /* 33222222222211111111110000000000
26097                                                     10987654321098765432109876543210
26098                                                     x10111101x0xxxxxxx1x11xxxxxxxxxx
26099                                                     frsqrts.  */
26100                                                  return 560;
26101                                                }
26102                                            }
26103                                        }
26104                                    }
26105                                }
26106                            }
26107                          else
26108                            {
26109                              if (((word >> 11) & 0x1) == 0)
26110                                {
26111                                  if (((word >> 12) & 0x1) == 0)
26112                                    {
26113                                      if (((word >> 13) & 0x1) == 0)
26114                                        {
26115                                          /* 33222222222211111111110000000000
26116                                             10987654321098765432109876543210
26117                                             xx111110xx0xxxxxxx000xxxxxxxxxxx
26118                                             sqrdmlah.  */
26119                                          return 588;
26120                                        }
26121                                      else
26122                                        {
26123                                          if (((word >> 23) & 0x1) == 0)
26124                                            {
26125                                              /* 33222222222211111111110000000000
26126                                                 10987654321098765432109876543210
26127                                                 xx1111100x0xxxxxxx100xxxxxxxxxxx
26128                                                 fcmge.  */
26129                                              return 573;
26130                                            }
26131                                          else
26132                                            {
26133                                              /* 33222222222211111111110000000000
26134                                                 10987654321098765432109876543210
26135                                                 xx1111101x0xxxxxxx100xxxxxxxxxxx
26136                                                 fcmgt.  */
26137                                              return 579;
26138                                            }
26139                                        }
26140                                    }
26141                                  else
26142                                    {
26143                                      /* 33222222222211111111110000000000
26144                                         10987654321098765432109876543210
26145                                         xx111110xx0xxxxxxxx10xxxxxxxxxxx
26146                                         fabd.  */
26147                                      return 577;
26148                                    }
26149                                }
26150                              else
26151                                {
26152                                  if (((word >> 13) & 0x1) == 0)
26153                                    {
26154                                      /* 33222222222211111111110000000000
26155                                         10987654321098765432109876543210
26156                                         xx111110xx0xxxxxxx0x1xxxxxxxxxxx
26157                                         sqrdmlsh.  */
26158                                      return 589;
26159                                    }
26160                                  else
26161                                    {
26162                                      if (((word >> 23) & 0x1) == 0)
26163                                        {
26164                                          /* 33222222222211111111110000000000
26165                                             10987654321098765432109876543210
26166                                             xx1111100x0xxxxxxx1x1xxxxxxxxxxx
26167                                             facge.  */
26168                                          return 575;
26169                                        }
26170                                      else
26171                                        {
26172                                          /* 33222222222211111111110000000000
26173                                             10987654321098765432109876543210
26174                                             xx1111101x0xxxxxxx1x1xxxxxxxxxxx
26175                                             facgt.  */
26176                                          return 581;
26177                                        }
26178                                    }
26179                                }
26180                            }
26181                        }
26182                    }
26183                  else
26184                    {
26185                      if (((word >> 28) & 0x1) == 0)
26186                        {
26187                          if (((word >> 15) & 0x1) == 0)
26188                            {
26189                              if (((word >> 29) & 0x1) == 0)
26190                                {
26191                                  if (((word >> 31) & 0x1) == 0)
26192                                    {
26193                                      if (((word >> 10) & 0x1) == 0)
26194                                        {
26195                                          if (((word >> 11) & 0x1) == 0)
26196                                            {
26197                                              if (((word >> 12) & 0x1) == 0)
26198                                                {
26199                                                  if (((word >> 13) & 0x1) == 0)
26200                                                    {
26201                                                      if (((word >> 14) & 0x1) == 0)
26202                                                        {
26203                                                          if (((word >> 30) & 0x1) == 0)
26204                                                            {
26205                                                              /* 33222222222211111111110000000000
26206                                                                 10987654321098765432109876543210
26207                                                                 00001110xx1xxxxx000000xxxxxxxxxx
26208                                                                 saddl.  */
26209                                                              return 44;
26210                                                            }
26211                                                          else
26212                                                            {
26213                                                              /* 33222222222211111111110000000000
26214                                                                 10987654321098765432109876543210
26215                                                                 01001110xx1xxxxx000000xxxxxxxxxx
26216                                                                 saddl2.  */
26217                                                              return 45;
26218                                                            }
26219                                                        }
26220                                                      else
26221                                                        {
26222                                                          if (((word >> 30) & 0x1) == 0)
26223                                                            {
26224                                                              /* 33222222222211111111110000000000
26225                                                                 10987654321098765432109876543210
26226                                                                 00001110xx1xxxxx010000xxxxxxxxxx
26227                                                                 addhn.  */
26228                                                              return 52;
26229                                                            }
26230                                                          else
26231                                                            {
26232                                                              /* 33222222222211111111110000000000
26233                                                                 10987654321098765432109876543210
26234                                                                 01001110xx1xxxxx010000xxxxxxxxxx
26235                                                                 addhn2.  */
26236                                                              return 53;
26237                                                            }
26238                                                        }
26239                                                    }
26240                                                  else
26241                                                    {
26242                                                      if (((word >> 14) & 0x1) == 0)
26243                                                        {
26244                                                          if (((word >> 30) & 0x1) == 0)
26245                                                            {
26246                                                              /* 33222222222211111111110000000000
26247                                                                 10987654321098765432109876543210
26248                                                                 00001110xx1xxxxx001000xxxxxxxxxx
26249                                                                 ssubl.  */
26250                                                              return 48;
26251                                                            }
26252                                                          else
26253                                                            {
26254                                                              /* 33222222222211111111110000000000
26255                                                                 10987654321098765432109876543210
26256                                                                 01001110xx1xxxxx001000xxxxxxxxxx
26257                                                                 ssubl2.  */
26258                                                              return 49;
26259                                                            }
26260                                                        }
26261                                                      else
26262                                                        {
26263                                                          if (((word >> 30) & 0x1) == 0)
26264                                                            {
26265                                                              /* 33222222222211111111110000000000
26266                                                                 10987654321098765432109876543210
26267                                                                 00001110xx1xxxxx011000xxxxxxxxxx
26268                                                                 subhn.  */
26269                                                              return 56;
26270                                                            }
26271                                                          else
26272                                                            {
26273                                                              /* 33222222222211111111110000000000
26274                                                                 10987654321098765432109876543210
26275                                                                 01001110xx1xxxxx011000xxxxxxxxxx
26276                                                                 subhn2.  */
26277                                                              return 57;
26278                                                            }
26279                                                        }
26280                                                    }
26281                                                }
26282                                              else
26283                                                {
26284                                                  if (((word >> 13) & 0x1) == 0)
26285                                                    {
26286                                                      if (((word >> 14) & 0x1) == 0)
26287                                                        {
26288                                                          if (((word >> 30) & 0x1) == 0)
26289                                                            {
26290                                                              /* 33222222222211111111110000000000
26291                                                                 10987654321098765432109876543210
26292                                                                 00001110xx1xxxxx000100xxxxxxxxxx
26293                                                                 saddw.  */
26294                                                              return 46;
26295                                                            }
26296                                                          else
26297                                                            {
26298                                                              /* 33222222222211111111110000000000
26299                                                                 10987654321098765432109876543210
26300                                                                 01001110xx1xxxxx000100xxxxxxxxxx
26301                                                                 saddw2.  */
26302                                                              return 47;
26303                                                            }
26304                                                        }
26305                                                      else
26306                                                        {
26307                                                          if (((word >> 30) & 0x1) == 0)
26308                                                            {
26309                                                              /* 33222222222211111111110000000000
26310                                                                 10987654321098765432109876543210
26311                                                                 00001110xx1xxxxx010100xxxxxxxxxx
26312                                                                 sabal.  */
26313                                                              return 54;
26314                                                            }
26315                                                          else
26316                                                            {
26317                                                              /* 33222222222211111111110000000000
26318                                                                 10987654321098765432109876543210
26319                                                                 01001110xx1xxxxx010100xxxxxxxxxx
26320                                                                 sabal2.  */
26321                                                              return 55;
26322                                                            }
26323                                                        }
26324                                                    }
26325                                                  else
26326                                                    {
26327                                                      if (((word >> 14) & 0x1) == 0)
26328                                                        {
26329                                                          if (((word >> 30) & 0x1) == 0)
26330                                                            {
26331                                                              /* 33222222222211111111110000000000
26332                                                                 10987654321098765432109876543210
26333                                                                 00001110xx1xxxxx001100xxxxxxxxxx
26334                                                                 ssubw.  */
26335                                                              return 50;
26336                                                            }
26337                                                          else
26338                                                            {
26339                                                              /* 33222222222211111111110000000000
26340                                                                 10987654321098765432109876543210
26341                                                                 01001110xx1xxxxx001100xxxxxxxxxx
26342                                                                 ssubw2.  */
26343                                                              return 51;
26344                                                            }
26345                                                        }
26346                                                      else
26347                                                        {
26348                                                          if (((word >> 30) & 0x1) == 0)
26349                                                            {
26350                                                              /* 33222222222211111111110000000000
26351                                                                 10987654321098765432109876543210
26352                                                                 00001110xx1xxxxx011100xxxxxxxxxx
26353                                                                 sabdl.  */
26354                                                              return 58;
26355                                                            }
26356                                                          else
26357                                                            {
26358                                                              /* 33222222222211111111110000000000
26359                                                                 10987654321098765432109876543210
26360                                                                 01001110xx1xxxxx011100xxxxxxxxxx
26361                                                                 sabdl2.  */
26362                                                              return 59;
26363                                                            }
26364                                                        }
26365                                                    }
26366                                                }
26367                                            }
26368                                          else
26369                                            {
26370                                              if (((word >> 12) & 0x1) == 0)
26371                                                {
26372                                                  if (((word >> 13) & 0x1) == 0)
26373                                                    {
26374                                                      if (((word >> 14) & 0x1) == 0)
26375                                                        {
26376                                                          /* 33222222222211111111110000000000
26377                                                             10987654321098765432109876543210
26378                                                             0x001110xx1xxxxx000010xxxxxxxxxx
26379                                                             rev64.  */
26380                                                          return 162;
26381                                                        }
26382                                                      else
26383                                                        {
26384                                                          if (((word >> 16) & 0x1) == 0)
26385                                                            {
26386                                                              if (((word >> 19) & 0x1) == 0)
26387                                                                {
26388                                                                  /* 33222222222211111111110000000000
26389                                                                     10987654321098765432109876543210
26390                                                                     0x001110xx1x0xx0010010xxxxxxxxxx
26391                                                                     cls.  */
26392                                                                  return 166;
26393                                                                }
26394                                                              else
26395                                                                {
26396                                                                  /* 33222222222211111111110000000000
26397                                                                     10987654321098765432109876543210
26398                                                                     0x001110xx1x1xx0010010xxxxxxxxxx
26399                                                                     aese.  */
26400                                                                  return 671;
26401                                                                }
26402                                                            }
26403                                                          else
26404                                                            {
26405                                                              if (((word >> 30) & 0x1) == 0)
26406                                                                {
26407                                                                  /* 33222222222211111111110000000000
26408                                                                     10987654321098765432109876543210
26409                                                                     00001110xx1xxxx1010010xxxxxxxxxx
26410                                                                     sqxtn.  */
26411                                                                  return 176;
26412                                                                }
26413                                                              else
26414                                                                {
26415                                                                  /* 33222222222211111111110000000000
26416                                                                     10987654321098765432109876543210
26417                                                                     01001110xx1xxxx1010010xxxxxxxxxx
26418                                                                     sqxtn2.  */
26419                                                                  return 177;
26420                                                                }
26421                                                            }
26422                                                        }
26423                                                    }
26424                                                  else
26425                                                    {
26426                                                      if (((word >> 14) & 0x1) == 0)
26427                                                        {
26428                                                          if (((word >> 16) & 0x1) == 0)
26429                                                            {
26430                                                              /* 33222222222211111111110000000000
26431                                                                 10987654321098765432109876543210
26432                                                                 0x001110xx1xxxx0001010xxxxxxxxxx
26433                                                                 saddlp.  */
26434                                                              return 164;
26435                                                            }
26436                                                          else
26437                                                            {
26438                                                              if (((word >> 30) & 0x1) == 0)
26439                                                                {
26440                                                                  /* 33222222222211111111110000000000
26441                                                                     10987654321098765432109876543210
26442                                                                     00001110xx1xxxx1001010xxxxxxxxxx
26443                                                                     xtn.  */
26444                                                                  return 174;
26445                                                                }
26446                                                              else
26447                                                                {
26448                                                                  /* 33222222222211111111110000000000
26449                                                                     10987654321098765432109876543210
26450                                                                     01001110xx1xxxx1001010xxxxxxxxxx
26451                                                                     xtn2.  */
26452                                                                  return 175;
26453                                                                }
26454                                                            }
26455                                                        }
26456                                                      else
26457                                                        {
26458                                                          if (((word >> 16) & 0x1) == 0)
26459                                                            {
26460                                                              if (((word >> 19) & 0x1) == 0)
26461                                                                {
26462                                                                  /* 33222222222211111111110000000000
26463                                                                     10987654321098765432109876543210
26464                                                                     0x001110xx1x0xx0011010xxxxxxxxxx
26465                                                                     sadalp.  */
26466                                                                  return 168;
26467                                                                }
26468                                                              else
26469                                                                {
26470                                                                  /* 33222222222211111111110000000000
26471                                                                     10987654321098765432109876543210
26472                                                                     0x001110xx1x1xx0011010xxxxxxxxxx
26473                                                                     aesmc.  */
26474                                                                  return 673;
26475                                                                }
26476                                                            }
26477                                                          else
26478                                                            {
26479                                                              if (((word >> 23) & 0x1) == 0)
26480                                                                {
26481                                                                  if (((word >> 30) & 0x1) == 0)
26482                                                                    {
26483                                                                      /* 33222222222211111111110000000000
26484                                                                         10987654321098765432109876543210
26485                                                                         000011100x1xxxx1011010xxxxxxxxxx
26486                                                                         fcvtn.  */
26487                                                                      return 178;
26488                                                                    }
26489                                                                  else
26490                                                                    {
26491                                                                      /* 33222222222211111111110000000000
26492                                                                         10987654321098765432109876543210
26493                                                                         010011100x1xxxx1011010xxxxxxxxxx
26494                                                                         fcvtn2.  */
26495                                                                      return 179;
26496                                                                    }
26497                                                                }
26498                                                              else
26499                                                                {
26500                                                                  if (((word >> 30) & 0x1) == 0)
26501                                                                    {
26502                                                                      /* 33222222222211111111110000000000
26503                                                                         10987654321098765432109876543210
26504                                                                         000011101x1xxxx1011010xxxxxxxxxx
26505                                                                         bfcvtn.  */
26506                                                                      return 3066;
26507                                                                    }
26508                                                                  else
26509                                                                    {
26510                                                                      /* 33222222222211111111110000000000
26511                                                                         10987654321098765432109876543210
26512                                                                         010011101x1xxxx1011010xxxxxxxxxx
26513                                                                         bfcvtn2.  */
26514                                                                      return 3067;
26515                                                                    }
26516                                                                }
26517                                                            }
26518                                                        }
26519                                                    }
26520                                                }
26521                                              else
26522                                                {
26523                                                  if (((word >> 13) & 0x1) == 0)
26524                                                    {
26525                                                      if (((word >> 14) & 0x1) == 0)
26526                                                        {
26527                                                          /* 33222222222211111111110000000000
26528                                                             10987654321098765432109876543210
26529                                                             0x001110xx1xxxxx000110xxxxxxxxxx
26530                                                             rev16.  */
26531                                                          return 163;
26532                                                        }
26533                                                      else
26534                                                        {
26535                                                          if (((word >> 19) & 0x1) == 0)
26536                                                            {
26537                                                              /* 33222222222211111111110000000000
26538                                                                 10987654321098765432109876543210
26539                                                                 0x001110xx1x0xxx010110xxxxxxxxxx
26540                                                                 cnt.  */
26541                                                              return 167;
26542                                                            }
26543                                                          else
26544                                                            {
26545                                                              /* 33222222222211111111110000000000
26546                                                                 10987654321098765432109876543210
26547                                                                 0x001110xx1x1xxx010110xxxxxxxxxx
26548                                                                 aesd.  */
26549                                                              return 672;
26550                                                            }
26551                                                        }
26552                                                    }
26553                                                  else
26554                                                    {
26555                                                      if (((word >> 14) & 0x1) == 0)
26556                                                        {
26557                                                          if (((word >> 20) & 0x1) == 0)
26558                                                            {
26559                                                              /* 33222222222211111111110000000000
26560                                                                 10987654321098765432109876543210
26561                                                                 0x001110xx10xxxx001110xxxxxxxxxx
26562                                                                 suqadd.  */
26563                                                              return 165;
26564                                                            }
26565                                                          else
26566                                                            {
26567                                                              /* 33222222222211111111110000000000
26568                                                                 10987654321098765432109876543210
26569                                                                 0x001110xx11xxxx001110xxxxxxxxxx
26570                                                                 saddlv.  */
26571                                                              return 29;
26572                                                            }
26573                                                        }
26574                                                      else
26575                                                        {
26576                                                          if (((word >> 16) & 0x1) == 0)
26577                                                            {
26578                                                              if (((word >> 19) & 0x1) == 0)
26579                                                                {
26580                                                                  /* 33222222222211111111110000000000
26581                                                                     10987654321098765432109876543210
26582                                                                     0x001110xx1x0xx0011110xxxxxxxxxx
26583                                                                     sqabs.  */
26584                                                                  return 169;
26585                                                                }
26586                                                              else
26587                                                                {
26588                                                                  /* 33222222222211111111110000000000
26589                                                                     10987654321098765432109876543210
26590                                                                     0x001110xx1x1xx0011110xxxxxxxxxx
26591                                                                     aesimc.  */
26592                                                                  return 674;
26593                                                                }
26594                                                            }
26595                                                          else
26596                                                            {
26597                                                              if (((word >> 30) & 0x1) == 0)
26598                                                                {
26599                                                                  /* 33222222222211111111110000000000
26600                                                                     10987654321098765432109876543210
26601                                                                     00001110xx1xxxx1011110xxxxxxxxxx
26602                                                                     fcvtl.  */
26603                                                                  return 180;
26604                                                                }
26605                                                              else
26606                                                                {
26607                                                                  /* 33222222222211111111110000000000
26608                                                                     10987654321098765432109876543210
26609                                                                     01001110xx1xxxx1011110xxxxxxxxxx
26610                                                                     fcvtl2.  */
26611                                                                  return 181;
26612                                                                }
26613                                                            }
26614                                                        }
26615                                                    }
26616                                                }
26617                                            }
26618                                        }
26619                                      else
26620                                        {
26621                                          if (((word >> 11) & 0x1) == 0)
26622                                            {
26623                                              if (((word >> 12) & 0x1) == 0)
26624                                                {
26625                                                  if (((word >> 13) & 0x1) == 0)
26626                                                    {
26627                                                      if (((word >> 14) & 0x1) == 0)
26628                                                        {
26629                                                          /* 33222222222211111111110000000000
26630                                                             10987654321098765432109876543210
26631                                                             0x001110xx1xxxxx000001xxxxxxxxxx
26632                                                             shadd.  */
26633                                                          return 268;
26634                                                        }
26635                                                      else
26636                                                        {
26637                                                          /* 33222222222211111111110000000000
26638                                                             10987654321098765432109876543210
26639                                                             0x001110xx1xxxxx010001xxxxxxxxxx
26640                                                             sshl.  */
26641                                                          return 275;
26642                                                        }
26643                                                    }
26644                                                  else
26645                                                    {
26646                                                      if (((word >> 14) & 0x1) == 0)
26647                                                        {
26648                                                          /* 33222222222211111111110000000000
26649                                                             10987654321098765432109876543210
26650                                                             0x001110xx1xxxxx001001xxxxxxxxxx
26651                                                             shsub.  */
26652                                                          return 271;
26653                                                        }
26654                                                      else
26655                                                        {
26656                                                          /* 33222222222211111111110000000000
26657                                                             10987654321098765432109876543210
26658                                                             0x001110xx1xxxxx011001xxxxxxxxxx
26659                                                             smax.  */
26660                                                          return 279;
26661                                                        }
26662                                                    }
26663                                                }
26664                                              else
26665                                                {
26666                                                  if (((word >> 13) & 0x1) == 0)
26667                                                    {
26668                                                      if (((word >> 14) & 0x1) == 0)
26669                                                        {
26670                                                          /* 33222222222211111111110000000000
26671                                                             10987654321098765432109876543210
26672                                                             0x001110xx1xxxxx000101xxxxxxxxxx
26673                                                             srhadd.  */
26674                                                          return 270;
26675                                                        }
26676                                                      else
26677                                                        {
26678                                                          /* 33222222222211111111110000000000
26679                                                             10987654321098765432109876543210
26680                                                             0x001110xx1xxxxx010101xxxxxxxxxx
26681                                                             srshl.  */
26682                                                          return 277;
26683                                                        }
26684                                                    }
26685                                                  else
26686                                                    {
26687                                                      if (((word >> 14) & 0x1) == 0)
26688                                                        {
26689                                                          /* 33222222222211111111110000000000
26690                                                             10987654321098765432109876543210
26691                                                             0x001110xx1xxxxx001101xxxxxxxxxx
26692                                                             cmgt.  */
26693                                                          return 273;
26694                                                        }
26695                                                      else
26696                                                        {
26697                                                          /* 33222222222211111111110000000000
26698                                                             10987654321098765432109876543210
26699                                                             0x001110xx1xxxxx011101xxxxxxxxxx
26700                                                             sabd.  */
26701                                                          return 281;
26702                                                        }
26703                                                    }
26704                                                }
26705                                            }
26706                                          else
26707                                            {
26708                                              if (((word >> 12) & 0x1) == 0)
26709                                                {
26710                                                  if (((word >> 13) & 0x1) == 0)
26711                                                    {
26712                                                      if (((word >> 14) & 0x1) == 0)
26713                                                        {
26714                                                          /* 33222222222211111111110000000000
26715                                                             10987654321098765432109876543210
26716                                                             0x001110xx1xxxxx000011xxxxxxxxxx
26717                                                             sqadd.  */
26718                                                          return 269;
26719                                                        }
26720                                                      else
26721                                                        {
26722                                                          /* 33222222222211111111110000000000
26723                                                             10987654321098765432109876543210
26724                                                             0x001110xx1xxxxx010011xxxxxxxxxx
26725                                                             sqshl.  */
26726                                                          return 276;
26727                                                        }
26728                                                    }
26729                                                  else
26730                                                    {
26731                                                      if (((word >> 14) & 0x1) == 0)
26732                                                        {
26733                                                          /* 33222222222211111111110000000000
26734                                                             10987654321098765432109876543210
26735                                                             0x001110xx1xxxxx001011xxxxxxxxxx
26736                                                             sqsub.  */
26737                                                          return 272;
26738                                                        }
26739                                                      else
26740                                                        {
26741                                                          /* 33222222222211111111110000000000
26742                                                             10987654321098765432109876543210
26743                                                             0x001110xx1xxxxx011011xxxxxxxxxx
26744                                                             smin.  */
26745                                                          return 280;
26746                                                        }
26747                                                    }
26748                                                }
26749                                              else
26750                                                {
26751                                                  if (((word >> 13) & 0x1) == 0)
26752                                                    {
26753                                                      if (((word >> 14) & 0x1) == 0)
26754                                                        {
26755                                                          if (((word >> 22) & 0x1) == 0)
26756                                                            {
26757                                                              if (((word >> 23) & 0x1) == 0)
26758                                                                {
26759                                                                  /* 33222222222211111111110000000000
26760                                                                     10987654321098765432109876543210
26761                                                                     0x001110001xxxxx000111xxxxxxxxxx
26762                                                                     and.  */
26763                                                                  return 305;
26764                                                                }
26765                                                              else
26766                                                                {
26767                                                                  /* 33222222222211111111110000000000
26768                                                                     10987654321098765432109876543210
26769                                                                     0x001110101xxxxx000111xxxxxxxxxx
26770                                                                     orr.  */
26771                                                                  return 317;
26772                                                                }
26773                                                            }
26774                                                          else
26775                                                            {
26776                                                              if (((word >> 23) & 0x1) == 0)
26777                                                                {
26778                                                                  /* 33222222222211111111110000000000
26779                                                                     10987654321098765432109876543210
26780                                                                     0x001110011xxxxx000111xxxxxxxxxx
26781                                                                     bic.  */
26782                                                                  return 306;
26783                                                                }
26784                                                              else
26785                                                                {
26786                                                                  /* 33222222222211111111110000000000
26787                                                                     10987654321098765432109876543210
26788                                                                     0x001110111xxxxx000111xxxxxxxxxx
26789                                                                     orn.  */
26790                                                                  return 319;
26791                                                                }
26792                                                            }
26793                                                        }
26794                                                      else
26795                                                        {
26796                                                          /* 33222222222211111111110000000000
26797                                                             10987654321098765432109876543210
26798                                                             0x001110xx1xxxxx010111xxxxxxxxxx
26799                                                             sqrshl.  */
26800                                                          return 278;
26801                                                        }
26802                                                    }
26803                                                  else
26804                                                    {
26805                                                      if (((word >> 14) & 0x1) == 0)
26806                                                        {
26807                                                          /* 33222222222211111111110000000000
26808                                                             10987654321098765432109876543210
26809                                                             0x001110xx1xxxxx001111xxxxxxxxxx
26810                                                             cmge.  */
26811                                                          return 274;
26812                                                        }
26813                                                      else
26814                                                        {
26815                                                          /* 33222222222211111111110000000000
26816                                                             10987654321098765432109876543210
26817                                                             0x001110xx1xxxxx011111xxxxxxxxxx
26818                                                             saba.  */
26819                                                          return 282;
26820                                                        }
26821                                                    }
26822                                                }
26823                                            }
26824                                        }
26825                                    }
26826                                  else
26827                                    {
26828                                      /* 33222222222211111111110000000000
26829                                         10987654321098765432109876543210
26830                                         1x001110xx1xxxxx0xxxxxxxxxxxxxxx
26831                                         bcax.  */
26832                                      return 2984;
26833                                    }
26834                                }
26835                              else
26836                                {
26837                                  if (((word >> 10) & 0x1) == 0)
26838                                    {
26839                                      if (((word >> 11) & 0x1) == 0)
26840                                        {
26841                                          if (((word >> 12) & 0x1) == 0)
26842                                            {
26843                                              if (((word >> 13) & 0x1) == 0)
26844                                                {
26845                                                  if (((word >> 14) & 0x1) == 0)
26846                                                    {
26847                                                      if (((word >> 30) & 0x1) == 0)
26848                                                        {
26849                                                          /* 33222222222211111111110000000000
26850                                                             10987654321098765432109876543210
26851                                                             x0101110xx1xxxxx000000xxxxxxxxxx
26852                                                             uaddl.  */
26853                                                          return 76;
26854                                                        }
26855                                                      else
26856                                                        {
26857                                                          /* 33222222222211111111110000000000
26858                                                             10987654321098765432109876543210
26859                                                             x1101110xx1xxxxx000000xxxxxxxxxx
26860                                                             uaddl2.  */
26861                                                          return 77;
26862                                                        }
26863                                                    }
26864                                                  else
26865                                                    {
26866                                                      if (((word >> 30) & 0x1) == 0)
26867                                                        {
26868                                                          /* 33222222222211111111110000000000
26869                                                             10987654321098765432109876543210
26870                                                             x0101110xx1xxxxx010000xxxxxxxxxx
26871                                                             raddhn.  */
26872                                                          return 84;
26873                                                        }
26874                                                      else
26875                                                        {
26876                                                          /* 33222222222211111111110000000000
26877                                                             10987654321098765432109876543210
26878                                                             x1101110xx1xxxxx010000xxxxxxxxxx
26879                                                             raddhn2.  */
26880                                                          return 85;
26881                                                        }
26882                                                    }
26883                                                }
26884                                              else
26885                                                {
26886                                                  if (((word >> 14) & 0x1) == 0)
26887                                                    {
26888                                                      if (((word >> 30) & 0x1) == 0)
26889                                                        {
26890                                                          /* 33222222222211111111110000000000
26891                                                             10987654321098765432109876543210
26892                                                             x0101110xx1xxxxx001000xxxxxxxxxx
26893                                                             usubl.  */
26894                                                          return 80;
26895                                                        }
26896                                                      else
26897                                                        {
26898                                                          /* 33222222222211111111110000000000
26899                                                             10987654321098765432109876543210
26900                                                             x1101110xx1xxxxx001000xxxxxxxxxx
26901                                                             usubl2.  */
26902                                                          return 81;
26903                                                        }
26904                                                    }
26905                                                  else
26906                                                    {
26907                                                      if (((word >> 30) & 0x1) == 0)
26908                                                        {
26909                                                          /* 33222222222211111111110000000000
26910                                                             10987654321098765432109876543210
26911                                                             x0101110xx1xxxxx011000xxxxxxxxxx
26912                                                             rsubhn.  */
26913                                                          return 88;
26914                                                        }
26915                                                      else
26916                                                        {
26917                                                          /* 33222222222211111111110000000000
26918                                                             10987654321098765432109876543210
26919                                                             x1101110xx1xxxxx011000xxxxxxxxxx
26920                                                             rsubhn2.  */
26921                                                          return 89;
26922                                                        }
26923                                                    }
26924                                                }
26925                                            }
26926                                          else
26927                                            {
26928                                              if (((word >> 13) & 0x1) == 0)
26929                                                {
26930                                                  if (((word >> 14) & 0x1) == 0)
26931                                                    {
26932                                                      if (((word >> 30) & 0x1) == 0)
26933                                                        {
26934                                                          /* 33222222222211111111110000000000
26935                                                             10987654321098765432109876543210
26936                                                             x0101110xx1xxxxx000100xxxxxxxxxx
26937                                                             uaddw.  */
26938                                                          return 78;
26939                                                        }
26940                                                      else
26941                                                        {
26942                                                          /* 33222222222211111111110000000000
26943                                                             10987654321098765432109876543210
26944                                                             x1101110xx1xxxxx000100xxxxxxxxxx
26945                                                             uaddw2.  */
26946                                                          return 79;
26947                                                        }
26948                                                    }
26949                                                  else
26950                                                    {
26951                                                      if (((word >> 30) & 0x1) == 0)
26952                                                        {
26953                                                          /* 33222222222211111111110000000000
26954                                                             10987654321098765432109876543210
26955                                                             x0101110xx1xxxxx010100xxxxxxxxxx
26956                                                             uabal.  */
26957                                                          return 86;
26958                                                        }
26959                                                      else
26960                                                        {
26961                                                          /* 33222222222211111111110000000000
26962                                                             10987654321098765432109876543210
26963                                                             x1101110xx1xxxxx010100xxxxxxxxxx
26964                                                             uabal2.  */
26965                                                          return 87;
26966                                                        }
26967                                                    }
26968                                                }
26969                                              else
26970                                                {
26971                                                  if (((word >> 14) & 0x1) == 0)
26972                                                    {
26973                                                      if (((word >> 30) & 0x1) == 0)
26974                                                        {
26975                                                          /* 33222222222211111111110000000000
26976                                                             10987654321098765432109876543210
26977                                                             x0101110xx1xxxxx001100xxxxxxxxxx
26978                                                             usubw.  */
26979                                                          return 82;
26980                                                        }
26981                                                      else
26982                                                        {
26983                                                          /* 33222222222211111111110000000000
26984                                                             10987654321098765432109876543210
26985                                                             x1101110xx1xxxxx001100xxxxxxxxxx
26986                                                             usubw2.  */
26987                                                          return 83;
26988                                                        }
26989                                                    }
26990                                                  else
26991                                                    {
26992                                                      if (((word >> 30) & 0x1) == 0)
26993                                                        {
26994                                                          /* 33222222222211111111110000000000
26995                                                             10987654321098765432109876543210
26996                                                             x0101110xx1xxxxx011100xxxxxxxxxx
26997                                                             uabdl.  */
26998                                                          return 90;
26999                                                        }
27000                                                      else
27001                                                        {
27002                                                          /* 33222222222211111111110000000000
27003                                                             10987654321098765432109876543210
27004                                                             x1101110xx1xxxxx011100xxxxxxxxxx
27005                                                             uabdl2.  */
27006                                                          return 91;
27007                                                        }
27008                                                    }
27009                                                }
27010                                            }
27011                                        }
27012                                      else
27013                                        {
27014                                          if (((word >> 12) & 0x1) == 0)
27015                                            {
27016                                              if (((word >> 13) & 0x1) == 0)
27017                                                {
27018                                                  if (((word >> 14) & 0x1) == 0)
27019                                                    {
27020                                                      /* 33222222222211111111110000000000
27021                                                         10987654321098765432109876543210
27022                                                         xx101110xx1xxxxx000010xxxxxxxxxx
27023                                                         rev32.  */
27024                                                      return 213;
27025                                                    }
27026                                                  else
27027                                                    {
27028                                                      if (((word >> 16) & 0x1) == 0)
27029                                                        {
27030                                                          /* 33222222222211111111110000000000
27031                                                             10987654321098765432109876543210
27032                                                             xx101110xx1xxxx0010010xxxxxxxxxx
27033                                                             clz.  */
27034                                                          return 216;
27035                                                        }
27036                                                      else
27037                                                        {
27038                                                          if (((word >> 30) & 0x1) == 0)
27039                                                            {
27040                                                              /* 33222222222211111111110000000000
27041                                                                 10987654321098765432109876543210
27042                                                                 x0101110xx1xxxx1010010xxxxxxxxxx
27043                                                                 uqxtn.  */
27044                                                              return 226;
27045                                                            }
27046                                                          else
27047                                                            {
27048                                                              /* 33222222222211111111110000000000
27049                                                                 10987654321098765432109876543210
27050                                                                 x1101110xx1xxxx1010010xxxxxxxxxx
27051                                                                 uqxtn2.  */
27052                                                              return 227;
27053                                                            }
27054                                                        }
27055                                                    }
27056                                                }
27057                                              else
27058                                                {
27059                                                  if (((word >> 14) & 0x1) == 0)
27060                                                    {
27061                                                      if (((word >> 16) & 0x1) == 0)
27062                                                        {
27063                                                          /* 33222222222211111111110000000000
27064                                                             10987654321098765432109876543210
27065                                                             xx101110xx1xxxx0001010xxxxxxxxxx
27066                                                             uaddlp.  */
27067                                                          return 214;
27068                                                        }
27069                                                      else
27070                                                        {
27071                                                          if (((word >> 30) & 0x1) == 0)
27072                                                            {
27073                                                              /* 33222222222211111111110000000000
27074                                                                 10987654321098765432109876543210
27075                                                                 x0101110xx1xxxx1001010xxxxxxxxxx
27076                                                                 sqxtun.  */
27077                                                              return 222;
27078                                                            }
27079                                                          else
27080                                                            {
27081                                                              /* 33222222222211111111110000000000
27082                                                                 10987654321098765432109876543210
27083                                                                 x1101110xx1xxxx1001010xxxxxxxxxx
27084                                                                 sqxtun2.  */
27085                                                              return 223;
27086                                                            }
27087                                                        }
27088                                                    }
27089                                                  else
27090                                                    {
27091                                                      if (((word >> 16) & 0x1) == 0)
27092                                                        {
27093                                                          /* 33222222222211111111110000000000
27094                                                             10987654321098765432109876543210
27095                                                             xx101110xx1xxxx0011010xxxxxxxxxx
27096                                                             uadalp.  */
27097                                                          return 217;
27098                                                        }
27099                                                      else
27100                                                        {
27101                                                          if (((word >> 30) & 0x1) == 0)
27102                                                            {
27103                                                              /* 33222222222211111111110000000000
27104                                                                 10987654321098765432109876543210
27105                                                                 x0101110xx1xxxx1011010xxxxxxxxxx
27106                                                                 fcvtxn.  */
27107                                                              return 228;
27108                                                            }
27109                                                          else
27110                                                            {
27111                                                              /* 33222222222211111111110000000000
27112                                                                 10987654321098765432109876543210
27113                                                                 x1101110xx1xxxx1011010xxxxxxxxxx
27114                                                                 fcvtxn2.  */
27115                                                              return 229;
27116                                                            }
27117                                                        }
27118                                                    }
27119                                                }
27120                                            }
27121                                          else
27122                                            {
27123                                              if (((word >> 13) & 0x1) == 0)
27124                                                {
27125                                                  if (((word >> 22) & 0x1) == 0)
27126                                                    {
27127                                                      /* 33222222222211111111110000000000
27128                                                         10987654321098765432109876543210
27129                                                         xx101110x01xxxxx0x0110xxxxxxxxxx
27130                                                         not.  */
27131                                                      return 242;
27132                                                    }
27133                                                  else
27134                                                    {
27135                                                      /* 33222222222211111111110000000000
27136                                                         10987654321098765432109876543210
27137                                                         xx101110x11xxxxx0x0110xxxxxxxxxx
27138                                                         rbit.  */
27139                                                      return 244;
27140                                                    }
27141                                                }
27142                                              else
27143                                                {
27144                                                  if (((word >> 14) & 0x1) == 0)
27145                                                    {
27146                                                      if (((word >> 16) & 0x1) == 0)
27147                                                        {
27148                                                          if (((word >> 20) & 0x1) == 0)
27149                                                            {
27150                                                              /* 33222222222211111111110000000000
27151                                                                 10987654321098765432109876543210
27152                                                                 xx101110xx10xxx0001110xxxxxxxxxx
27153                                                                 usqadd.  */
27154                                                              return 215;
27155                                                            }
27156                                                          else
27157                                                            {
27158                                                              /* 33222222222211111111110000000000
27159                                                                 10987654321098765432109876543210
27160                                                                 xx101110xx11xxx0001110xxxxxxxxxx
27161                                                                 uaddlv.  */
27162                                                              return 33;
27163                                                            }
27164                                                        }
27165                                                      else
27166                                                        {
27167                                                          if (((word >> 30) & 0x1) == 0)
27168                                                            {
27169                                                              /* 33222222222211111111110000000000
27170                                                                 10987654321098765432109876543210
27171                                                                 x0101110xx1xxxx1001110xxxxxxxxxx
27172                                                                 shll.  */
27173                                                              return 224;
27174                                                            }
27175                                                          else
27176                                                            {
27177                                                              /* 33222222222211111111110000000000
27178                                                                 10987654321098765432109876543210
27179                                                                 x1101110xx1xxxx1001110xxxxxxxxxx
27180                                                                 shll2.  */
27181                                                              return 225;
27182                                                            }
27183                                                        }
27184                                                    }
27185                                                  else
27186                                                    {
27187                                                      /* 33222222222211111111110000000000
27188                                                         10987654321098765432109876543210
27189                                                         xx101110xx1xxxxx011110xxxxxxxxxx
27190                                                         sqneg.  */
27191                                                      return 218;
27192                                                    }
27193                                                }
27194                                            }
27195                                        }
27196                                    }
27197                                  else
27198                                    {
27199                                      if (((word >> 11) & 0x1) == 0)
27200                                        {
27201                                          if (((word >> 12) & 0x1) == 0)
27202                                            {
27203                                              if (((word >> 13) & 0x1) == 0)
27204                                                {
27205                                                  if (((word >> 14) & 0x1) == 0)
27206                                                    {
27207                                                      /* 33222222222211111111110000000000
27208                                                         10987654321098765432109876543210
27209                                                         xx101110xx1xxxxx000001xxxxxxxxxx
27210                                                         uhadd.  */
27211                                                      return 320;
27212                                                    }
27213                                                  else
27214                                                    {
27215                                                      /* 33222222222211111111110000000000
27216                                                         10987654321098765432109876543210
27217                                                         xx101110xx1xxxxx010001xxxxxxxxxx
27218                                                         ushl.  */
27219                                                      return 327;
27220                                                    }
27221                                                }
27222                                              else
27223                                                {
27224                                                  if (((word >> 14) & 0x1) == 0)
27225                                                    {
27226                                                      /* 33222222222211111111110000000000
27227                                                         10987654321098765432109876543210
27228                                                         xx101110xx1xxxxx001001xxxxxxxxxx
27229                                                         uhsub.  */
27230                                                      return 323;
27231                                                    }
27232                                                  else
27233                                                    {
27234                                                      /* 33222222222211111111110000000000
27235                                                         10987654321098765432109876543210
27236                                                         xx101110xx1xxxxx011001xxxxxxxxxx
27237                                                         umax.  */
27238                                                      return 331;
27239                                                    }
27240                                                }
27241                                            }
27242                                          else
27243                                            {
27244                                              if (((word >> 13) & 0x1) == 0)
27245                                                {
27246                                                  if (((word >> 14) & 0x1) == 0)
27247                                                    {
27248                                                      /* 33222222222211111111110000000000
27249                                                         10987654321098765432109876543210
27250                                                         xx101110xx1xxxxx000101xxxxxxxxxx
27251                                                         urhadd.  */
27252                                                      return 322;
27253                                                    }
27254                                                  else
27255                                                    {
27256                                                      /* 33222222222211111111110000000000
27257                                                         10987654321098765432109876543210
27258                                                         xx101110xx1xxxxx010101xxxxxxxxxx
27259                                                         urshl.  */
27260                                                      return 329;
27261                                                    }
27262                                                }
27263                                              else
27264                                                {
27265                                                  if (((word >> 14) & 0x1) == 0)
27266                                                    {
27267                                                      /* 33222222222211111111110000000000
27268                                                         10987654321098765432109876543210
27269                                                         xx101110xx1xxxxx001101xxxxxxxxxx
27270                                                         cmhi.  */
27271                                                      return 325;
27272                                                    }
27273                                                  else
27274                                                    {
27275                                                      /* 33222222222211111111110000000000
27276                                                         10987654321098765432109876543210
27277                                                         xx101110xx1xxxxx011101xxxxxxxxxx
27278                                                         uabd.  */
27279                                                      return 333;
27280                                                    }
27281                                                }
27282                                            }
27283                                        }
27284                                      else
27285                                        {
27286                                          if (((word >> 12) & 0x1) == 0)
27287                                            {
27288                                              if (((word >> 13) & 0x1) == 0)
27289                                                {
27290                                                  if (((word >> 14) & 0x1) == 0)
27291                                                    {
27292                                                      /* 33222222222211111111110000000000
27293                                                         10987654321098765432109876543210
27294                                                         xx101110xx1xxxxx000011xxxxxxxxxx
27295                                                         uqadd.  */
27296                                                      return 321;
27297                                                    }
27298                                                  else
27299                                                    {
27300                                                      /* 33222222222211111111110000000000
27301                                                         10987654321098765432109876543210
27302                                                         xx101110xx1xxxxx010011xxxxxxxxxx
27303                                                         uqshl.  */
27304                                                      return 328;
27305                                                    }
27306                                                }
27307                                              else
27308                                                {
27309                                                  if (((word >> 14) & 0x1) == 0)
27310                                                    {
27311                                                      /* 33222222222211111111110000000000
27312                                                         10987654321098765432109876543210
27313                                                         xx101110xx1xxxxx001011xxxxxxxxxx
27314                                                         uqsub.  */
27315                                                      return 324;
27316                                                    }
27317                                                  else
27318                                                    {
27319                                                      /* 33222222222211111111110000000000
27320                                                         10987654321098765432109876543210
27321                                                         xx101110xx1xxxxx011011xxxxxxxxxx
27322                                                         umin.  */
27323                                                      return 332;
27324                                                    }
27325                                                }
27326                                            }
27327                                          else
27328                                            {
27329                                              if (((word >> 13) & 0x1) == 0)
27330                                                {
27331                                                  if (((word >> 14) & 0x1) == 0)
27332                                                    {
27333                                                      if (((word >> 22) & 0x1) == 0)
27334                                                        {
27335                                                          if (((word >> 23) & 0x1) == 0)
27336                                                            {
27337                                                              /* 33222222222211111111110000000000
27338                                                                 10987654321098765432109876543210
27339                                                                 xx101110001xxxxx000111xxxxxxxxxx
27340                                                                 eor.  */
27341                                                              return 356;
27342                                                            }
27343                                                          else
27344                                                            {
27345                                                              /* 33222222222211111111110000000000
27346                                                                 10987654321098765432109876543210
27347                                                                 xx101110101xxxxx000111xxxxxxxxxx
27348                                                                 bit.  */
27349                                                              return 368;
27350                                                            }
27351                                                        }
27352                                                      else
27353                                                        {
27354                                                          if (((word >> 23) & 0x1) == 0)
27355                                                            {
27356                                                              /* 33222222222211111111110000000000
27357                                                                 10987654321098765432109876543210
27358                                                                 xx101110011xxxxx000111xxxxxxxxxx
27359                                                                 bsl.  */
27360                                                              return 357;
27361                                                            }
27362                                                          else
27363                                                            {
27364                                                              /* 33222222222211111111110000000000
27365                                                                 10987654321098765432109876543210
27366                                                                 xx101110111xxxxx000111xxxxxxxxxx
27367                                                                 bif.  */
27368                                                              return 369;
27369                                                            }
27370                                                        }
27371                                                    }
27372                                                  else
27373                                                    {
27374                                                      /* 33222222222211111111110000000000
27375                                                         10987654321098765432109876543210
27376                                                         xx101110xx1xxxxx010111xxxxxxxxxx
27377                                                         uqrshl.  */
27378                                                      return 330;
27379                                                    }
27380                                                }
27381                                              else
27382                                                {
27383                                                  if (((word >> 14) & 0x1) == 0)
27384                                                    {
27385                                                      /* 33222222222211111111110000000000
27386                                                         10987654321098765432109876543210
27387                                                         xx101110xx1xxxxx001111xxxxxxxxxx
27388                                                         cmhs.  */
27389                                                      return 326;
27390                                                    }
27391                                                  else
27392                                                    {
27393                                                      /* 33222222222211111111110000000000
27394                                                         10987654321098765432109876543210
27395                                                         xx101110xx1xxxxx011111xxxxxxxxxx
27396                                                         uaba.  */
27397                                                      return 334;
27398                                                    }
27399                                                }
27400                                            }
27401                                        }
27402                                    }
27403                                }
27404                            }
27405                          else
27406                            {
27407                              if (((word >> 10) & 0x1) == 0)
27408                                {
27409                                  if (((word >> 11) & 0x1) == 0)
27410                                    {
27411                                      if (((word >> 12) & 0x1) == 0)
27412                                        {
27413                                          if (((word >> 13) & 0x1) == 0)
27414                                            {
27415                                              if (((word >> 14) & 0x1) == 0)
27416                                                {
27417                                                  if (((word >> 29) & 0x1) == 0)
27418                                                    {
27419                                                      if (((word >> 30) & 0x1) == 0)
27420                                                        {
27421                                                          /* 33222222222211111111110000000000
27422                                                             10987654321098765432109876543210
27423                                                             x0001110xx1xxxxx100000xxxxxxxxxx
27424                                                             smlal.  */
27425                                                          return 60;
27426                                                        }
27427                                                      else
27428                                                        {
27429                                                          if (((word >> 31) & 0x1) == 0)
27430                                                            {
27431                                                              /* 33222222222211111111110000000000
27432                                                                 10987654321098765432109876543210
27433                                                                 01001110xx1xxxxx100000xxxxxxxxxx
27434                                                                 smlal2.  */
27435                                                              return 61;
27436                                                            }
27437                                                          else
27438                                                            {
27439                                                              /* 33222222222211111111110000000000
27440                                                                 10987654321098765432109876543210
27441                                                                 11001110xx1xxxxx100000xxxxxxxxxx
27442                                                                 sha512h.  */
27443                                                              return 2977;
27444                                                            }
27445                                                        }
27446                                                    }
27447                                                  else
27448                                                    {
27449                                                      if (((word >> 30) & 0x1) == 0)
27450                                                        {
27451                                                          /* 33222222222211111111110000000000
27452                                                             10987654321098765432109876543210
27453                                                             x0101110xx1xxxxx100000xxxxxxxxxx
27454                                                             umlal.  */
27455                                                          return 92;
27456                                                        }
27457                                                      else
27458                                                        {
27459                                                          /* 33222222222211111111110000000000
27460                                                             10987654321098765432109876543210
27461                                                             x1101110xx1xxxxx100000xxxxxxxxxx
27462                                                             umlal2.  */
27463                                                          return 93;
27464                                                        }
27465                                                    }
27466                                                }
27467                                              else
27468                                                {
27469                                                  if (((word >> 29) & 0x1) == 0)
27470                                                    {
27471                                                      if (((word >> 30) & 0x1) == 0)
27472                                                        {
27473                                                          /* 33222222222211111111110000000000
27474                                                             10987654321098765432109876543210
27475                                                             x0001110xx1xxxxx110000xxxxxxxxxx
27476                                                             smull.  */
27477                                                          return 68;
27478                                                        }
27479                                                      else
27480                                                        {
27481                                                          if (((word >> 31) & 0x1) == 0)
27482                                                            {
27483                                                              /* 33222222222211111111110000000000
27484                                                                 10987654321098765432109876543210
27485                                                                 01001110xx1xxxxx110000xxxxxxxxxx
27486                                                                 smull2.  */
27487                                                              return 69;
27488                                                            }
27489                                                          else
27490                                                            {
27491                                                              /* 33222222222211111111110000000000
27492                                                                 10987654321098765432109876543210
27493                                                                 11001110xx1xxxxx110000xxxxxxxxxx
27494                                                                 sm3partw1.  */
27495                                                              return 2990;
27496                                                            }
27497                                                        }
27498                                                    }
27499                                                  else
27500                                                    {
27501                                                      if (((word >> 30) & 0x1) == 0)
27502                                                        {
27503                                                          /* 33222222222211111111110000000000
27504                                                             10987654321098765432109876543210
27505                                                             x0101110xx1xxxxx110000xxxxxxxxxx
27506                                                             umull.  */
27507                                                          return 96;
27508                                                        }
27509                                                      else
27510                                                        {
27511                                                          /* 33222222222211111111110000000000
27512                                                             10987654321098765432109876543210
27513                                                             x1101110xx1xxxxx110000xxxxxxxxxx
27514                                                             umull2.  */
27515                                                          return 97;
27516                                                        }
27517                                                    }
27518                                                }
27519                                            }
27520                                          else
27521                                            {
27522                                              if (((word >> 14) & 0x1) == 0)
27523                                                {
27524                                                  if (((word >> 29) & 0x1) == 0)
27525                                                    {
27526                                                      if (((word >> 30) & 0x1) == 0)
27527                                                        {
27528                                                          /* 33222222222211111111110000000000
27529                                                             10987654321098765432109876543210
27530                                                             x0001110xx1xxxxx101000xxxxxxxxxx
27531                                                             smlsl.  */
27532                                                          return 64;
27533                                                        }
27534                                                      else
27535                                                        {
27536                                                          /* 33222222222211111111110000000000
27537                                                             10987654321098765432109876543210
27538                                                             x1001110xx1xxxxx101000xxxxxxxxxx
27539                                                             smlsl2.  */
27540                                                          return 65;
27541                                                        }
27542                                                    }
27543                                                  else
27544                                                    {
27545                                                      if (((word >> 30) & 0x1) == 0)
27546                                                        {
27547                                                          /* 33222222222211111111110000000000
27548                                                             10987654321098765432109876543210
27549                                                             x0101110xx1xxxxx101000xxxxxxxxxx
27550                                                             umlsl.  */
27551                                                          return 94;
27552                                                        }
27553                                                      else
27554                                                        {
27555                                                          /* 33222222222211111111110000000000
27556                                                             10987654321098765432109876543210
27557                                                             x1101110xx1xxxxx101000xxxxxxxxxx
27558                                                             umlsl2.  */
27559                                                          return 95;
27560                                                        }
27561                                                    }
27562                                                }
27563                                              else
27564                                                {
27565                                                  if (((word >> 22) & 0x1) == 0)
27566                                                    {
27567                                                      if (((word >> 30) & 0x1) == 0)
27568                                                        {
27569                                                          /* 33222222222211111111110000000000
27570                                                             10987654321098765432109876543210
27571                                                             x0x01110x01xxxxx111000xxxxxxxxxx
27572                                                             pmull.  */
27573                                                          return 72;
27574                                                        }
27575                                                      else
27576                                                        {
27577                                                          /* 33222222222211111111110000000000
27578                                                             10987654321098765432109876543210
27579                                                             x1x01110x01xxxxx111000xxxxxxxxxx
27580                                                             pmull2.  */
27581                                                          return 74;
27582                                                        }
27583                                                    }
27584                                                  else
27585                                                    {
27586                                                      if (((word >> 30) & 0x1) == 0)
27587                                                        {
27588                                                          /* 33222222222211111111110000000000
27589                                                             10987654321098765432109876543210
27590                                                             x0x01110x11xxxxx111000xxxxxxxxxx
27591                                                             pmull.  */
27592                                                          return 73;
27593                                                        }
27594                                                      else
27595                                                        {
27596                                                          /* 33222222222211111111110000000000
27597                                                             10987654321098765432109876543210
27598                                                             x1x01110x11xxxxx111000xxxxxxxxxx
27599                                                             pmull2.  */
27600                                                          return 75;
27601                                                        }
27602                                                    }
27603                                                }
27604                                            }
27605                                        }
27606                                      else
27607                                        {
27608                                          if (((word >> 13) & 0x1) == 0)
27609                                            {
27610                                              if (((word >> 14) & 0x1) == 0)
27611                                                {
27612                                                  if (((word >> 30) & 0x1) == 0)
27613                                                    {
27614                                                      /* 33222222222211111111110000000000
27615                                                         10987654321098765432109876543210
27616                                                         x0x01110xx1xxxxx100100xxxxxxxxxx
27617                                                         sqdmlal.  */
27618                                                      return 62;
27619                                                    }
27620                                                  else
27621                                                    {
27622                                                      /* 33222222222211111111110000000000
27623                                                         10987654321098765432109876543210
27624                                                         x1x01110xx1xxxxx100100xxxxxxxxxx
27625                                                         sqdmlal2.  */
27626                                                      return 63;
27627                                                    }
27628                                                }
27629                                              else
27630                                                {
27631                                                  if (((word >> 30) & 0x1) == 0)
27632                                                    {
27633                                                      /* 33222222222211111111110000000000
27634                                                         10987654321098765432109876543210
27635                                                         x0x01110xx1xxxxx110100xxxxxxxxxx
27636                                                         sqdmull.  */
27637                                                      return 70;
27638                                                    }
27639                                                  else
27640                                                    {
27641                                                      /* 33222222222211111111110000000000
27642                                                         10987654321098765432109876543210
27643                                                         x1x01110xx1xxxxx110100xxxxxxxxxx
27644                                                         sqdmull2.  */
27645                                                      return 71;
27646                                                    }
27647                                                }
27648                                            }
27649                                          else
27650                                            {
27651                                              if (((word >> 30) & 0x1) == 0)
27652                                                {
27653                                                  /* 33222222222211111111110000000000
27654                                                     10987654321098765432109876543210
27655                                                     x0x01110xx1xxxxx1x1100xxxxxxxxxx
27656                                                     sqdmlsl.  */
27657                                                  return 66;
27658                                                }
27659                                              else
27660                                                {
27661                                                  /* 33222222222211111111110000000000
27662                                                     10987654321098765432109876543210
27663                                                     x1x01110xx1xxxxx1x1100xxxxxxxxxx
27664                                                     sqdmlsl2.  */
27665                                                  return 67;
27666                                                }
27667                                            }
27668                                        }
27669                                    }
27670                                  else
27671                                    {
27672                                      if (((word >> 12) & 0x1) == 0)
27673                                        {
27674                                          if (((word >> 13) & 0x1) == 0)
27675                                            {
27676                                              if (((word >> 14) & 0x1) == 0)
27677                                                {
27678                                                  if (((word >> 29) & 0x1) == 0)
27679                                                    {
27680                                                      if (((word >> 31) & 0x1) == 0)
27681                                                        {
27682                                                          if (((word >> 16) & 0x1) == 0)
27683                                                            {
27684                                                              /* 33222222222211111111110000000000
27685                                                                 10987654321098765432109876543210
27686                                                                 0x001110xx1xxxx0100010xxxxxxxxxx
27687                                                                 cmgt.  */
27688                                                              return 170;
27689                                                            }
27690                                                          else
27691                                                            {
27692                                                              if (((word >> 19) & 0x1) == 0)
27693                                                                {
27694                                                                  if (((word >> 23) & 0x1) == 0)
27695                                                                    {
27696                                                                      /* 33222222222211111111110000000000
27697                                                                         10987654321098765432109876543210
27698                                                                         0x0011100x1x0xx1100010xxxxxxxxxx
27699                                                                         frintn.  */
27700                                                                      return 182;
27701                                                                    }
27702                                                                  else
27703                                                                    {
27704                                                                      /* 33222222222211111111110000000000
27705                                                                         10987654321098765432109876543210
27706                                                                         0x0011101x1x0xx1100010xxxxxxxxxx
27707                                                                         frintp.  */
27708                                                                      return 202;
27709                                                                    }
27710                                                                }
27711                                                              else
27712                                                                {
27713                                                                  if (((word >> 23) & 0x1) == 0)
27714                                                                    {
27715                                                                      /* 33222222222211111111110000000000
27716                                                                         10987654321098765432109876543210
27717                                                                         0x0011100x1x1xx1100010xxxxxxxxxx
27718                                                                         frintn.  */
27719                                                                      return 183;
27720                                                                    }
27721                                                                  else
27722                                                                    {
27723                                                                      /* 33222222222211111111110000000000
27724                                                                         10987654321098765432109876543210
27725                                                                         0x0011101x1x1xx1100010xxxxxxxxxx
27726                                                                         frintp.  */
27727                                                                      return 203;
27728                                                                    }
27729                                                                }
27730                                                            }
27731                                                        }
27732                                                      else
27733                                                        {
27734                                                          /* 33222222222211111111110000000000
27735                                                             10987654321098765432109876543210
27736                                                             1x001110xx1xxxxx100010xxxxxxxxxx
27737                                                             sha512su1.  */
27738                                                          return 2980;
27739                                                        }
27740                                                    }
27741                                                  else
27742                                                    {
27743                                                      if (((word >> 16) & 0x1) == 0)
27744                                                        {
27745                                                          /* 33222222222211111111110000000000
27746                                                             10987654321098765432109876543210
27747                                                             xx101110xx1xxxx0100010xxxxxxxxxx
27748                                                             cmge.  */
27749                                                          return 219;
27750                                                        }
27751                                                      else
27752                                                        {
27753                                                          if (((word >> 19) & 0x1) == 0)
27754                                                            {
27755                                                              /* 33222222222211111111110000000000
27756                                                                 10987654321098765432109876543210
27757                                                                 xx101110xx1x0xx1100010xxxxxxxxxx
27758                                                                 frinta.  */
27759                                                              return 230;
27760                                                            }
27761                                                          else
27762                                                            {
27763                                                              /* 33222222222211111111110000000000
27764                                                                 10987654321098765432109876543210
27765                                                                 xx101110xx1x1xx1100010xxxxxxxxxx
27766                                                                 frinta.  */
27767                                                              return 231;
27768                                                            }
27769                                                        }
27770                                                    }
27771                                                }
27772                                              else
27773                                                {
27774                                                  if (((word >> 23) & 0x1) == 0)
27775                                                    {
27776                                                      if (((word >> 29) & 0x1) == 0)
27777                                                        {
27778                                                          if (((word >> 31) & 0x1) == 0)
27779                                                            {
27780                                                              if (((word >> 16) & 0x1) == 0)
27781                                                                {
27782                                                                  /* 33222222222211111111110000000000
27783                                                                     10987654321098765432109876543210
27784                                                                     0x0011100x1xxxx0110010xxxxxxxxxx
27785                                                                     fmaxnmv.  */
27786                                                                  return 37;
27787                                                                }
27788                                                              else
27789                                                                {
27790                                                                  if (((word >> 19) & 0x1) == 0)
27791                                                                    {
27792                                                                      /* 33222222222211111111110000000000
27793                                                                         10987654321098765432109876543210
27794                                                                         0x0011100x1x0xx1110010xxxxxxxxxx
27795                                                                         fcvtas.  */
27796                                                                      return 190;
27797                                                                    }
27798                                                                  else
27799                                                                    {
27800                                                                      /* 33222222222211111111110000000000
27801                                                                         10987654321098765432109876543210
27802                                                                         0x0011100x1x1xx1110010xxxxxxxxxx
27803                                                                         fcvtas.  */
27804                                                                      return 191;
27805                                                                    }
27806                                                                }
27807                                                            }
27808                                                          else
27809                                                            {
27810                                                              /* 33222222222211111111110000000000
27811                                                                 10987654321098765432109876543210
27812                                                                 1x0011100x1xxxxx110010xxxxxxxxxx
27813                                                                 sm4ekey.  */
27814                                                              return 2993;
27815                                                            }
27816                                                        }
27817                                                      else
27818                                                        {
27819                                                          if (((word >> 16) & 0x1) == 0)
27820                                                            {
27821                                                              /* 33222222222211111111110000000000
27822                                                                 10987654321098765432109876543210
27823                                                                 xx1011100x1xxxx0110010xxxxxxxxxx
27824                                                                 fmaxnmv.  */
27825                                                              return 36;
27826                                                            }
27827                                                          else
27828                                                            {
27829                                                              if (((word >> 19) & 0x1) == 0)
27830                                                                {
27831                                                                  /* 33222222222211111111110000000000
27832                                                                     10987654321098765432109876543210
27833                                                                     xx1011100x1x0xx1110010xxxxxxxxxx
27834                                                                     fcvtau.  */
27835                                                                  return 238;
27836                                                                }
27837                                                              else
27838                                                                {
27839                                                                  /* 33222222222211111111110000000000
27840                                                                     10987654321098765432109876543210
27841                                                                     xx1011100x1x1xx1110010xxxxxxxxxx
27842                                                                     fcvtau.  */
27843                                                                  return 239;
27844                                                                }
27845                                                            }
27846                                                        }
27847                                                    }
27848                                                  else
27849                                                    {
27850                                                      if (((word >> 16) & 0x1) == 0)
27851                                                        {
27852                                                          if (((word >> 19) & 0x1) == 0)
27853                                                            {
27854                                                              if (((word >> 20) & 0x1) == 0)
27855                                                                {
27856                                                                  if (((word >> 29) & 0x1) == 0)
27857                                                                    {
27858                                                                      /* 33222222222211111111110000000000
27859                                                                         10987654321098765432109876543210
27860                                                                         xx0011101x100xx0110010xxxxxxxxxx
27861                                                                         fcmgt.  */
27862                                                                      return 194;
27863                                                                    }
27864                                                                  else
27865                                                                    {
27866                                                                      /* 33222222222211111111110000000000
27867                                                                         10987654321098765432109876543210
27868                                                                         xx1011101x100xx0110010xxxxxxxxxx
27869                                                                         fcmge.  */
27870                                                                      return 245;
27871                                                                    }
27872                                                                }
27873                                                              else
27874                                                                {
27875                                                                  if (((word >> 29) & 0x1) == 0)
27876                                                                    {
27877                                                                      /* 33222222222211111111110000000000
27878                                                                         10987654321098765432109876543210
27879                                                                         xx0011101x110xx0110010xxxxxxxxxx
27880                                                                         fminnmv.  */
27881                                                                      return 41;
27882                                                                    }
27883                                                                  else
27884                                                                    {
27885                                                                      /* 33222222222211111111110000000000
27886                                                                         10987654321098765432109876543210
27887                                                                         xx1011101x110xx0110010xxxxxxxxxx
27888                                                                         fminnmv.  */
27889                                                                      return 40;
27890                                                                    }
27891                                                                }
27892                                                            }
27893                                                          else
27894                                                            {
27895                                                              if (((word >> 29) & 0x1) == 0)
27896                                                                {
27897                                                                  /* 33222222222211111111110000000000
27898                                                                     10987654321098765432109876543210
27899                                                                     xx0011101x1x1xx0110010xxxxxxxxxx
27900                                                                     fcmgt.  */
27901                                                                  return 195;
27902                                                                }
27903                                                              else
27904                                                                {
27905                                                                  /* 33222222222211111111110000000000
27906                                                                     10987654321098765432109876543210
27907                                                                     xx1011101x1x1xx0110010xxxxxxxxxx
27908                                                                     fcmge.  */
27909                                                                  return 246;
27910                                                                }
27911                                                            }
27912                                                        }
27913                                                      else
27914                                                        {
27915                                                          if (((word >> 29) & 0x1) == 0)
27916                                                            {
27917                                                              /* 33222222222211111111110000000000
27918                                                                 10987654321098765432109876543210
27919                                                                 xx0011101x1xxxx1110010xxxxxxxxxx
27920                                                                 urecpe.  */
27921                                                              return 210;
27922                                                            }
27923                                                          else
27924                                                            {
27925                                                              /* 33222222222211111111110000000000
27926                                                                 10987654321098765432109876543210
27927                                                                 xx1011101x1xxxx1110010xxxxxxxxxx
27928                                                                 ursqrte.  */
27929                                                              return 257;
27930                                                            }
27931                                                        }
27932                                                    }
27933                                                }
27934                                            }
27935                                          else
27936                                            {
27937                                              if (((word >> 14) & 0x1) == 0)
27938                                                {
27939                                                  if (((word >> 16) & 0x1) == 0)
27940                                                    {
27941                                                      if (((word >> 20) & 0x1) == 0)
27942                                                        {
27943                                                          /* 33222222222211111111110000000000
27944                                                             10987654321098765432109876543210
27945                                                             xxx01110xx10xxx0101010xxxxxxxxxx
27946                                                             cmlt.  */
27947                                                          return 172;
27948                                                        }
27949                                                      else
27950                                                        {
27951                                                          if (((word >> 29) & 0x1) == 0)
27952                                                            {
27953                                                              /* 33222222222211111111110000000000
27954                                                                 10987654321098765432109876543210
27955                                                                 xx001110xx11xxx0101010xxxxxxxxxx
27956                                                                 smaxv.  */
27957                                                              return 30;
27958                                                            }
27959                                                          else
27960                                                            {
27961                                                              /* 33222222222211111111110000000000
27962                                                                 10987654321098765432109876543210
27963                                                                 xx101110xx11xxx0101010xxxxxxxxxx
27964                                                                 umaxv.  */
27965                                                              return 34;
27966                                                            }
27967                                                        }
27968                                                    }
27969                                                  else
27970                                                    {
27971                                                      if (((word >> 19) & 0x1) == 0)
27972                                                        {
27973                                                          if (((word >> 20) & 0x1) == 0)
27974                                                            {
27975                                                              if (((word >> 23) & 0x1) == 0)
27976                                                                {
27977                                                                  if (((word >> 29) & 0x1) == 0)
27978                                                                    {
27979                                                                      /* 33222222222211111111110000000000
27980                                                                         10987654321098765432109876543210
27981                                                                         xx0011100x100xx1101010xxxxxxxxxx
27982                                                                         fcvtns.  */
27983                                                                      return 186;
27984                                                                    }
27985                                                                  else
27986                                                                    {
27987                                                                      /* 33222222222211111111110000000000
27988                                                                         10987654321098765432109876543210
27989                                                                         xx1011100x100xx1101010xxxxxxxxxx
27990                                                                         fcvtnu.  */
27991                                                                      return 234;
27992                                                                    }
27993                                                                }
27994                                                              else
27995                                                                {
27996                                                                  if (((word >> 29) & 0x1) == 0)
27997                                                                    {
27998                                                                      /* 33222222222211111111110000000000
27999                                                                         10987654321098765432109876543210
28000                                                                         xx0011101x100xx1101010xxxxxxxxxx
28001                                                                         fcvtps.  */
28002                                                                      return 206;
28003                                                                    }
28004                                                                  else
28005                                                                    {
28006                                                                      /* 33222222222211111111110000000000
28007                                                                         10987654321098765432109876543210
28008                                                                         xx1011101x100xx1101010xxxxxxxxxx
28009                                                                         fcvtpu.  */
28010                                                                      return 253;
28011                                                                    }
28012                                                                }
28013                                                            }
28014                                                          else
28015                                                            {
28016                                                              if (((word >> 29) & 0x1) == 0)
28017                                                                {
28018                                                                  /* 33222222222211111111110000000000
28019                                                                     10987654321098765432109876543210
28020                                                                     xx001110xx110xx1101010xxxxxxxxxx
28021                                                                     sminv.  */
28022                                                                  return 31;
28023                                                                }
28024                                                              else
28025                                                                {
28026                                                                  /* 33222222222211111111110000000000
28027                                                                     10987654321098765432109876543210
28028                                                                     xx101110xx110xx1101010xxxxxxxxxx
28029                                                                     uminv.  */
28030                                                                  return 35;
28031                                                                }
28032                                                            }
28033                                                        }
28034                                                      else
28035                                                        {
28036                                                          if (((word >> 23) & 0x1) == 0)
28037                                                            {
28038                                                              if (((word >> 29) & 0x1) == 0)
28039                                                                {
28040                                                                  /* 33222222222211111111110000000000
28041                                                                     10987654321098765432109876543210
28042                                                                     xx0011100x1x1xx1101010xxxxxxxxxx
28043                                                                     fcvtns.  */
28044                                                                  return 187;
28045                                                                }
28046                                                              else
28047                                                                {
28048                                                                  /* 33222222222211111111110000000000
28049                                                                     10987654321098765432109876543210
28050                                                                     xx1011100x1x1xx1101010xxxxxxxxxx
28051                                                                     fcvtnu.  */
28052                                                                  return 235;
28053                                                                }
28054                                                            }
28055                                                          else
28056                                                            {
28057                                                              if (((word >> 29) & 0x1) == 0)
28058                                                                {
28059                                                                  /* 33222222222211111111110000000000
28060                                                                     10987654321098765432109876543210
28061                                                                     xx0011101x1x1xx1101010xxxxxxxxxx
28062                                                                     fcvtps.  */
28063                                                                  return 207;
28064                                                                }
28065                                                              else
28066                                                                {
28067                                                                  /* 33222222222211111111110000000000
28068                                                                     10987654321098765432109876543210
28069                                                                     xx1011101x1x1xx1101010xxxxxxxxxx
28070                                                                     fcvtpu.  */
28071                                                                  return 254;
28072                                                                }
28073                                                            }
28074                                                        }
28075                                                    }
28076                                                }
28077                                              else
28078                                                {
28079                                                  if (((word >> 16) & 0x1) == 0)
28080                                                    {
28081                                                      if (((word >> 19) & 0x1) == 0)
28082                                                        {
28083                                                          /* 33222222222211111111110000000000
28084                                                             10987654321098765432109876543210
28085                                                             xxx01110xx1x0xx0111010xxxxxxxxxx
28086                                                             fcmlt.  */
28087                                                          return 198;
28088                                                        }
28089                                                      else
28090                                                        {
28091                                                          /* 33222222222211111111110000000000
28092                                                             10987654321098765432109876543210
28093                                                             xxx01110xx1x1xx0111010xxxxxxxxxx
28094                                                             fcmlt.  */
28095                                                          return 199;
28096                                                        }
28097                                                    }
28098                                                  else
28099                                                    {
28100                                                      if (((word >> 29) & 0x1) == 0)
28101                                                        {
28102                                                          /* 33222222222211111111110000000000
28103                                                             10987654321098765432109876543210
28104                                                             xx001110xx1xxxx1111010xxxxxxxxxx
28105                                                             frint32z.  */
28106                                                          return 158;
28107                                                        }
28108                                                      else
28109                                                        {
28110                                                          /* 33222222222211111111110000000000
28111                                                             10987654321098765432109876543210
28112                                                             xx101110xx1xxxx1111010xxxxxxxxxx
28113                                                             frint32x.  */
28114                                                          return 159;
28115                                                        }
28116                                                    }
28117                                                }
28118                                            }
28119                                        }
28120                                      else
28121                                        {
28122                                          if (((word >> 13) & 0x1) == 0)
28123                                            {
28124                                              if (((word >> 14) & 0x1) == 0)
28125                                                {
28126                                                  if (((word >> 16) & 0x1) == 0)
28127                                                    {
28128                                                      if (((word >> 29) & 0x1) == 0)
28129                                                        {
28130                                                          /* 33222222222211111111110000000000
28131                                                             10987654321098765432109876543210
28132                                                             xx001110xx1xxxx0100110xxxxxxxxxx
28133                                                             cmeq.  */
28134                                                          return 171;
28135                                                        }
28136                                                      else
28137                                                        {
28138                                                          /* 33222222222211111111110000000000
28139                                                             10987654321098765432109876543210
28140                                                             xx101110xx1xxxx0100110xxxxxxxxxx
28141                                                             cmle.  */
28142                                                          return 220;
28143                                                        }
28144                                                    }
28145                                                  else
28146                                                    {
28147                                                      if (((word >> 19) & 0x1) == 0)
28148                                                        {
28149                                                          if (((word >> 23) & 0x1) == 0)
28150                                                            {
28151                                                              if (((word >> 29) & 0x1) == 0)
28152                                                                {
28153                                                                  /* 33222222222211111111110000000000
28154                                                                     10987654321098765432109876543210
28155                                                                     xx0011100x1x0xx1100110xxxxxxxxxx
28156                                                                     frintm.  */
28157                                                                  return 184;
28158                                                                }
28159                                                              else
28160                                                                {
28161                                                                  /* 33222222222211111111110000000000
28162                                                                     10987654321098765432109876543210
28163                                                                     xx1011100x1x0xx1100110xxxxxxxxxx
28164                                                                     frintx.  */
28165                                                                  return 232;
28166                                                                }
28167                                                            }
28168                                                          else
28169                                                            {
28170                                                              if (((word >> 29) & 0x1) == 0)
28171                                                                {
28172                                                                  /* 33222222222211111111110000000000
28173                                                                     10987654321098765432109876543210
28174                                                                     xx0011101x1x0xx1100110xxxxxxxxxx
28175                                                                     frintz.  */
28176                                                                  return 204;
28177                                                                }
28178                                                              else
28179                                                                {
28180                                                                  /* 33222222222211111111110000000000
28181                                                                     10987654321098765432109876543210
28182                                                                     xx1011101x1x0xx1100110xxxxxxxxxx
28183                                                                     frinti.  */
28184                                                                  return 251;
28185                                                                }
28186                                                            }
28187                                                        }
28188                                                      else
28189                                                        {
28190                                                          if (((word >> 23) & 0x1) == 0)
28191                                                            {
28192                                                              if (((word >> 29) & 0x1) == 0)
28193                                                                {
28194                                                                  /* 33222222222211111111110000000000
28195                                                                     10987654321098765432109876543210
28196                                                                     xx0011100x1x1xx1100110xxxxxxxxxx
28197                                                                     frintm.  */
28198                                                                  return 185;
28199                                                                }
28200                                                              else
28201                                                                {
28202                                                                  /* 33222222222211111111110000000000
28203                                                                     10987654321098765432109876543210
28204                                                                     xx1011100x1x1xx1100110xxxxxxxxxx
28205                                                                     frintx.  */
28206                                                                  return 233;
28207                                                                }
28208                                                            }
28209                                                          else
28210                                                            {
28211                                                              if (((word >> 29) & 0x1) == 0)
28212                                                                {
28213                                                                  /* 33222222222211111111110000000000
28214                                                                     10987654321098765432109876543210
28215                                                                     xx0011101x1x1xx1100110xxxxxxxxxx
28216                                                                     frintz.  */
28217                                                                  return 205;
28218                                                                }
28219                                                              else
28220                                                                {
28221                                                                  /* 33222222222211111111110000000000
28222                                                                     10987654321098765432109876543210
28223                                                                     xx1011101x1x1xx1100110xxxxxxxxxx
28224                                                                     frinti.  */
28225                                                                  return 252;
28226                                                                }
28227                                                            }
28228                                                        }
28229                                                    }
28230                                                }
28231                                              else
28232                                                {
28233                                                  if (((word >> 16) & 0x1) == 0)
28234                                                    {
28235                                                      if (((word >> 19) & 0x1) == 0)
28236                                                        {
28237                                                          if (((word >> 29) & 0x1) == 0)
28238                                                            {
28239                                                              /* 33222222222211111111110000000000
28240                                                                 10987654321098765432109876543210
28241                                                                 xx001110xx1x0xx0110110xxxxxxxxxx
28242                                                                 fcmeq.  */
28243                                                              return 196;
28244                                                            }
28245                                                          else
28246                                                            {
28247                                                              /* 33222222222211111111110000000000
28248                                                                 10987654321098765432109876543210
28249                                                                 xx101110xx1x0xx0110110xxxxxxxxxx
28250                                                                 fcmle.  */
28251                                                              return 247;
28252                                                            }
28253                                                        }
28254                                                      else
28255                                                        {
28256                                                          if (((word >> 29) & 0x1) == 0)
28257                                                            {
28258                                                              /* 33222222222211111111110000000000
28259                                                                 10987654321098765432109876543210
28260                                                                 xx001110xx1x1xx0110110xxxxxxxxxx
28261                                                                 fcmeq.  */
28262                                                              return 197;
28263                                                            }
28264                                                          else
28265                                                            {
28266                                                              /* 33222222222211111111110000000000
28267                                                                 10987654321098765432109876543210
28268                                                                 xx101110xx1x1xx0110110xxxxxxxxxx
28269                                                                 fcmle.  */
28270                                                              return 248;
28271                                                            }
28272                                                        }
28273                                                    }
28274                                                  else
28275                                                    {
28276                                                      if (((word >> 19) & 0x1) == 0)
28277                                                        {
28278                                                          if (((word >> 23) & 0x1) == 0)
28279                                                            {
28280                                                              if (((word >> 29) & 0x1) == 0)
28281                                                                {
28282                                                                  /* 33222222222211111111110000000000
28283                                                                     10987654321098765432109876543210
28284                                                                     xx0011100x1x0xx1110110xxxxxxxxxx
28285                                                                     scvtf.  */
28286                                                                  return 192;
28287                                                                }
28288                                                              else
28289                                                                {
28290                                                                  /* 33222222222211111111110000000000
28291                                                                     10987654321098765432109876543210
28292                                                                     xx1011100x1x0xx1110110xxxxxxxxxx
28293                                                                     ucvtf.  */
28294                                                                  return 240;
28295                                                                }
28296                                                            }
28297                                                          else
28298                                                            {
28299                                                              if (((word >> 29) & 0x1) == 0)
28300                                                                {
28301                                                                  /* 33222222222211111111110000000000
28302                                                                     10987654321098765432109876543210
28303                                                                     xx0011101x1x0xx1110110xxxxxxxxxx
28304                                                                     frecpe.  */
28305                                                                  return 211;
28306                                                                }
28307                                                              else
28308                                                                {
28309                                                                  /* 33222222222211111111110000000000
28310                                                                     10987654321098765432109876543210
28311                                                                     xx1011101x1x0xx1110110xxxxxxxxxx
28312                                                                     frsqrte.  */
28313                                                                  return 258;
28314                                                                }
28315                                                            }
28316                                                        }
28317                                                      else
28318                                                        {
28319                                                          if (((word >> 23) & 0x1) == 0)
28320                                                            {
28321                                                              if (((word >> 29) & 0x1) == 0)
28322                                                                {
28323                                                                  /* 33222222222211111111110000000000
28324                                                                     10987654321098765432109876543210
28325                                                                     xx0011100x1x1xx1110110xxxxxxxxxx
28326                                                                     scvtf.  */
28327                                                                  return 193;
28328                                                                }
28329                                                              else
28330                                                                {
28331                                                                  /* 33222222222211111111110000000000
28332                                                                     10987654321098765432109876543210
28333                                                                     xx1011100x1x1xx1110110xxxxxxxxxx
28334                                                                     ucvtf.  */
28335                                                                  return 241;
28336                                                                }
28337                                                            }
28338                                                          else
28339                                                            {
28340                                                              if (((word >> 29) & 0x1) == 0)
28341                                                                {
28342                                                                  /* 33222222222211111111110000000000
28343                                                                     10987654321098765432109876543210
28344                                                                     xx0011101x1x1xx1110110xxxxxxxxxx
28345                                                                     frecpe.  */
28346                                                                  return 212;
28347                                                                }
28348                                                              else
28349                                                                {
28350                                                                  /* 33222222222211111111110000000000
28351                                                                     10987654321098765432109876543210
28352                                                                     xx1011101x1x1xx1110110xxxxxxxxxx
28353                                                                     frsqrte.  */
28354                                                                  return 259;
28355                                                                }
28356                                                            }
28357                                                        }
28358                                                    }
28359                                                }
28360                                            }
28361                                          else
28362                                            {
28363                                              if (((word >> 14) & 0x1) == 0)
28364                                                {
28365                                                  if (((word >> 16) & 0x1) == 0)
28366                                                    {
28367                                                      if (((word >> 29) & 0x1) == 0)
28368                                                        {
28369                                                          /* 33222222222211111111110000000000
28370                                                             10987654321098765432109876543210
28371                                                             xx001110xx1xxxx0101110xxxxxxxxxx
28372                                                             abs.  */
28373                                                          return 173;
28374                                                        }
28375                                                      else
28376                                                        {
28377                                                          /* 33222222222211111111110000000000
28378                                                             10987654321098765432109876543210
28379                                                             xx101110xx1xxxx0101110xxxxxxxxxx
28380                                                             neg.  */
28381                                                          return 221;
28382                                                        }
28383                                                    }
28384                                                  else
28385                                                    {
28386                                                      if (((word >> 19) & 0x1) == 0)
28387                                                        {
28388                                                          if (((word >> 20) & 0x1) == 0)
28389                                                            {
28390                                                              if (((word >> 23) & 0x1) == 0)
28391                                                                {
28392                                                                  if (((word >> 29) & 0x1) == 0)
28393                                                                    {
28394                                                                      /* 33222222222211111111110000000000
28395                                                                         10987654321098765432109876543210
28396                                                                         xx0011100x100xx1101110xxxxxxxxxx
28397                                                                         fcvtms.  */
28398                                                                      return 188;
28399                                                                    }
28400                                                                  else
28401                                                                    {
28402                                                                      /* 33222222222211111111110000000000
28403                                                                         10987654321098765432109876543210
28404                                                                         xx1011100x100xx1101110xxxxxxxxxx
28405                                                                         fcvtmu.  */
28406                                                                      return 236;
28407                                                                    }
28408                                                                }
28409                                                              else
28410                                                                {
28411                                                                  if (((word >> 29) & 0x1) == 0)
28412                                                                    {
28413                                                                      /* 33222222222211111111110000000000
28414                                                                         10987654321098765432109876543210
28415                                                                         xx0011101x100xx1101110xxxxxxxxxx
28416                                                                         fcvtzs.  */
28417                                                                      return 208;
28418                                                                    }
28419                                                                  else
28420                                                                    {
28421                                                                      /* 33222222222211111111110000000000
28422                                                                         10987654321098765432109876543210
28423                                                                         xx1011101x100xx1101110xxxxxxxxxx
28424                                                                         fcvtzu.  */
28425                                                                      return 255;
28426                                                                    }
28427                                                                }
28428                                                            }
28429                                                          else
28430                                                            {
28431                                                              /* 33222222222211111111110000000000
28432                                                                 10987654321098765432109876543210
28433                                                                 xxx01110xx110xx1101110xxxxxxxxxx
28434                                                                 addv.  */
28435                                                              return 32;
28436                                                            }
28437                                                        }
28438                                                      else
28439                                                        {
28440                                                          if (((word >> 23) & 0x1) == 0)
28441                                                            {
28442                                                              if (((word >> 29) & 0x1) == 0)
28443                                                                {
28444                                                                  /* 33222222222211111111110000000000
28445                                                                     10987654321098765432109876543210
28446                                                                     xx0011100x1x1xx1101110xxxxxxxxxx
28447                                                                     fcvtms.  */
28448                                                                  return 189;
28449                                                                }
28450                                                              else
28451                                                                {
28452                                                                  /* 33222222222211111111110000000000
28453                                                                     10987654321098765432109876543210
28454                                                                     xx1011100x1x1xx1101110xxxxxxxxxx
28455                                                                     fcvtmu.  */
28456                                                                  return 237;
28457                                                                }
28458                                                            }
28459                                                          else
28460                                                            {
28461                                                              if (((word >> 29) & 0x1) == 0)
28462                                                                {
28463                                                                  /* 33222222222211111111110000000000
28464                                                                     10987654321098765432109876543210
28465                                                                     xx0011101x1x1xx1101110xxxxxxxxxx
28466                                                                     fcvtzs.  */
28467                                                                  return 209;
28468                                                                }
28469                                                              else
28470                                                                {
28471                                                                  /* 33222222222211111111110000000000
28472                                                                     10987654321098765432109876543210
28473                                                                     xx1011101x1x1xx1101110xxxxxxxxxx
28474                                                                     fcvtzu.  */
28475                                                                  return 256;
28476                                                                }
28477                                                            }
28478                                                        }
28479                                                    }
28480                                                }
28481                                              else
28482                                                {
28483                                                  if (((word >> 16) & 0x1) == 0)
28484                                                    {
28485                                                      if (((word >> 19) & 0x1) == 0)
28486                                                        {
28487                                                          if (((word >> 20) & 0x1) == 0)
28488                                                            {
28489                                                              if (((word >> 29) & 0x1) == 0)
28490                                                                {
28491                                                                  /* 33222222222211111111110000000000
28492                                                                     10987654321098765432109876543210
28493                                                                     xx001110xx100xx0111110xxxxxxxxxx
28494                                                                     fabs.  */
28495                                                                  return 200;
28496                                                                }
28497                                                              else
28498                                                                {
28499                                                                  /* 33222222222211111111110000000000
28500                                                                     10987654321098765432109876543210
28501                                                                     xx101110xx100xx0111110xxxxxxxxxx
28502                                                                     fneg.  */
28503                                                                  return 249;
28504                                                                }
28505                                                            }
28506                                                          else
28507                                                            {
28508                                                              if (((word >> 23) & 0x1) == 0)
28509                                                                {
28510                                                                  if (((word >> 29) & 0x1) == 0)
28511                                                                    {
28512                                                                      /* 33222222222211111111110000000000
28513                                                                         10987654321098765432109876543210
28514                                                                         xx0011100x110xx0111110xxxxxxxxxx
28515                                                                         fmaxv.  */
28516                                                                      return 39;
28517                                                                    }
28518                                                                  else
28519                                                                    {
28520                                                                      /* 33222222222211111111110000000000
28521                                                                         10987654321098765432109876543210
28522                                                                         xx1011100x110xx0111110xxxxxxxxxx
28523                                                                         fmaxv.  */
28524                                                                      return 38;
28525                                                                    }
28526                                                                }
28527                                                              else
28528                                                                {
28529                                                                  if (((word >> 29) & 0x1) == 0)
28530                                                                    {
28531                                                                      /* 33222222222211111111110000000000
28532                                                                         10987654321098765432109876543210
28533                                                                         xx0011101x110xx0111110xxxxxxxxxx
28534                                                                         fminv.  */
28535                                                                      return 43;
28536                                                                    }
28537                                                                  else
28538                                                                    {
28539                                                                      /* 33222222222211111111110000000000
28540                                                                         10987654321098765432109876543210
28541                                                                         xx1011101x110xx0111110xxxxxxxxxx
28542                                                                         fminv.  */
28543                                                                      return 42;
28544                                                                    }
28545                                                                }
28546                                                            }
28547                                                        }
28548                                                      else
28549                                                        {
28550                                                          if (((word >> 29) & 0x1) == 0)
28551                                                            {
28552                                                              /* 33222222222211111111110000000000
28553                                                                 10987654321098765432109876543210
28554                                                                 xx001110xx1x1xx0111110xxxxxxxxxx
28555                                                                 fabs.  */
28556                                                              return 201;
28557                                                            }
28558                                                          else
28559                                                            {
28560                                                              /* 33222222222211111111110000000000
28561                                                                 10987654321098765432109876543210
28562                                                                 xx101110xx1x1xx0111110xxxxxxxxxx
28563                                                                 fneg.  */
28564                                                              return 250;
28565                                                            }
28566                                                        }
28567                                                    }
28568                                                  else
28569                                                    {
28570                                                      if (((word >> 19) & 0x1) == 0)
28571                                                        {
28572                                                          if (((word >> 23) & 0x1) == 0)
28573                                                            {
28574                                                              if (((word >> 29) & 0x1) == 0)
28575                                                                {
28576                                                                  /* 33222222222211111111110000000000
28577                                                                     10987654321098765432109876543210
28578                                                                     xx0011100x1x0xx1111110xxxxxxxxxx
28579                                                                     frint64z.  */
28580                                                                  return 160;
28581                                                                }
28582                                                              else
28583                                                                {
28584                                                                  /* 33222222222211111111110000000000
28585                                                                     10987654321098765432109876543210
28586                                                                     xx1011100x1x0xx1111110xxxxxxxxxx
28587                                                                     frint64x.  */
28588                                                                  return 161;
28589                                                                }
28590                                                            }
28591                                                          else
28592                                                            {
28593                                                              /* 33222222222211111111110000000000
28594                                                                 10987654321098765432109876543210
28595                                                                 xxx011101x1x0xx1111110xxxxxxxxxx
28596                                                                 fsqrt.  */
28597                                                              return 260;
28598                                                            }
28599                                                        }
28600                                                      else
28601                                                        {
28602                                                          /* 33222222222211111111110000000000
28603                                                             10987654321098765432109876543210
28604                                                             xxx01110xx1x1xx1111110xxxxxxxxxx
28605                                                             fsqrt.  */
28606                                                          return 261;
28607                                                        }
28608                                                    }
28609                                                }
28610                                            }
28611                                        }
28612                                    }
28613                                }
28614                              else
28615                                {
28616                                  if (((word >> 11) & 0x1) == 0)
28617                                    {
28618                                      if (((word >> 12) & 0x1) == 0)
28619                                        {
28620                                          if (((word >> 13) & 0x1) == 0)
28621                                            {
28622                                              if (((word >> 14) & 0x1) == 0)
28623                                                {
28624                                                  if (((word >> 29) & 0x1) == 0)
28625                                                    {
28626                                                      if (((word >> 31) & 0x1) == 0)
28627                                                        {
28628                                                          /* 33222222222211111111110000000000
28629                                                             10987654321098765432109876543210
28630                                                             0x001110xx1xxxxx100001xxxxxxxxxx
28631                                                             add.  */
28632                                                          return 283;
28633                                                        }
28634                                                      else
28635                                                        {
28636                                                          /* 33222222222211111111110000000000
28637                                                             10987654321098765432109876543210
28638                                                             1x001110xx1xxxxx100001xxxxxxxxxx
28639                                                             sha512h2.  */
28640                                                          return 2978;
28641                                                        }
28642                                                    }
28643                                                  else
28644                                                    {
28645                                                      /* 33222222222211111111110000000000
28646                                                         10987654321098765432109876543210
28647                                                         xx101110xx1xxxxx100001xxxxxxxxxx
28648                                                         sub.  */
28649                                                      return 335;
28650                                                    }
28651                                                }
28652                                              else
28653                                                {
28654                                                  if (((word >> 23) & 0x1) == 0)
28655                                                    {
28656                                                      if (((word >> 29) & 0x1) == 0)
28657                                                        {
28658                                                          if (((word >> 31) & 0x1) == 0)
28659                                                            {
28660                                                              /* 33222222222211111111110000000000
28661                                                                 10987654321098765432109876543210
28662                                                                 0x0011100x1xxxxx110001xxxxxxxxxx
28663                                                                 fmaxnm.  */
28664                                                              return 291;
28665                                                            }
28666                                                          else
28667                                                            {
28668                                                              /* 33222222222211111111110000000000
28669                                                                 10987654321098765432109876543210
28670                                                                 1x0011100x1xxxxx110001xxxxxxxxxx
28671                                                                 sm3partw2.  */
28672                                                              return 2991;
28673                                                            }
28674                                                        }
28675                                                      else
28676                                                        {
28677                                                          /* 33222222222211111111110000000000
28678                                                             10987654321098765432109876543210
28679                                                             xx1011100x1xxxxx110001xxxxxxxxxx
28680                                                             fmaxnmp.  */
28681                                                          return 342;
28682                                                        }
28683                                                    }
28684                                                  else
28685                                                    {
28686                                                      if (((word >> 29) & 0x1) == 0)
28687                                                        {
28688                                                          /* 33222222222211111111110000000000
28689                                                             10987654321098765432109876543210
28690                                                             xx0011101x1xxxxx110001xxxxxxxxxx
28691                                                             fminnm.  */
28692                                                          return 307;
28693                                                        }
28694                                                      else
28695                                                        {
28696                                                          /* 33222222222211111111110000000000
28697                                                             10987654321098765432109876543210
28698                                                             xx1011101x1xxxxx110001xxxxxxxxxx
28699                                                             fminnmp.  */
28700                                                          return 358;
28701                                                        }
28702                                                    }
28703                                                }
28704                                            }
28705                                          else
28706                                            {
28707                                              if (((word >> 14) & 0x1) == 0)
28708                                                {
28709                                                  if (((word >> 29) & 0x1) == 0)
28710                                                    {
28711                                                      /* 33222222222211111111110000000000
28712                                                         10987654321098765432109876543210
28713                                                         xx001110xx1xxxxx101001xxxxxxxxxx
28714                                                         smaxp.  */
28715                                                      return 287;
28716                                                    }
28717                                                  else
28718                                                    {
28719                                                      /* 33222222222211111111110000000000
28720                                                         10987654321098765432109876543210
28721                                                         xx101110xx1xxxxx101001xxxxxxxxxx
28722                                                         umaxp.  */
28723                                                      return 339;
28724                                                    }
28725                                                }
28726                                              else
28727                                                {
28728                                                  if (((word >> 23) & 0x1) == 0)
28729                                                    {
28730                                                      if (((word >> 29) & 0x1) == 0)
28731                                                        {
28732                                                          /* 33222222222211111111110000000000
28733                                                             10987654321098765432109876543210
28734                                                             xx0011100x1xxxxx111001xxxxxxxxxx
28735                                                             fcmeq.  */
28736                                                          return 299;
28737                                                        }
28738                                                      else
28739                                                        {
28740                                                          /* 33222222222211111111110000000000
28741                                                             10987654321098765432109876543210
28742                                                             xx1011100x1xxxxx111001xxxxxxxxxx
28743                                                             fcmge.  */
28744                                                          return 348;
28745                                                        }
28746                                                    }
28747                                                  else
28748                                                    {
28749                                                      /* 33222222222211111111110000000000
28750                                                         10987654321098765432109876543210
28751                                                         xxx011101x1xxxxx111001xxxxxxxxxx
28752                                                         fcmgt.  */
28753                                                      return 362;
28754                                                    }
28755                                                }
28756                                            }
28757                                        }
28758                                      else
28759                                        {
28760                                          if (((word >> 13) & 0x1) == 0)
28761                                            {
28762                                              if (((word >> 14) & 0x1) == 0)
28763                                                {
28764                                                  if (((word >> 29) & 0x1) == 0)
28765                                                    {
28766                                                      /* 33222222222211111111110000000000
28767                                                         10987654321098765432109876543210
28768                                                         xx001110xx1xxxxx100101xxxxxxxxxx
28769                                                         mla.  */
28770                                                      return 285;
28771                                                    }
28772                                                  else
28773                                                    {
28774                                                      /* 33222222222211111111110000000000
28775                                                         10987654321098765432109876543210
28776                                                         xx101110xx1xxxxx100101xxxxxxxxxx
28777                                                         mls.  */
28778                                                      return 337;
28779                                                    }
28780                                                }
28781                                              else
28782                                                {
28783                                                  if (((word >> 23) & 0x1) == 0)
28784                                                    {
28785                                                      if (((word >> 29) & 0x1) == 0)
28786                                                        {
28787                                                          /* 33222222222211111111110000000000
28788                                                             10987654321098765432109876543210
28789                                                             xx0011100x1xxxxx110101xxxxxxxxxx
28790                                                             fadd.  */
28791                                                          return 295;
28792                                                        }
28793                                                      else
28794                                                        {
28795                                                          /* 33222222222211111111110000000000
28796                                                             10987654321098765432109876543210
28797                                                             xx1011100x1xxxxx110101xxxxxxxxxx
28798                                                             faddp.  */
28799                                                          return 344;
28800                                                        }
28801                                                    }
28802                                                  else
28803                                                    {
28804                                                      if (((word >> 29) & 0x1) == 0)
28805                                                        {
28806                                                          /* 33222222222211111111110000000000
28807                                                             10987654321098765432109876543210
28808                                                             xx0011101x1xxxxx110101xxxxxxxxxx
28809                                                             fsub.  */
28810                                                          return 311;
28811                                                        }
28812                                                      else
28813                                                        {
28814                                                          /* 33222222222211111111110000000000
28815                                                             10987654321098765432109876543210
28816                                                             xx1011101x1xxxxx110101xxxxxxxxxx
28817                                                             fabd.  */
28818                                                          return 360;
28819                                                        }
28820                                                    }
28821                                                }
28822                                            }
28823                                          else
28824                                            {
28825                                              if (((word >> 14) & 0x1) == 0)
28826                                                {
28827                                                  if (((word >> 29) & 0x1) == 0)
28828                                                    {
28829                                                      /* 33222222222211111111110000000000
28830                                                         10987654321098765432109876543210
28831                                                         xx001110xx1xxxxx101101xxxxxxxxxx
28832                                                         sqdmulh.  */
28833                                                      return 289;
28834                                                    }
28835                                                  else
28836                                                    {
28837                                                      /* 33222222222211111111110000000000
28838                                                         10987654321098765432109876543210
28839                                                         xx101110xx1xxxxx101101xxxxxxxxxx
28840                                                         sqrdmulh.  */
28841                                                      return 341;
28842                                                    }
28843                                                }
28844                                              else
28845                                                {
28846                                                  if (((word >> 23) & 0x1) == 0)
28847                                                    {
28848                                                      if (((word >> 29) & 0x1) == 0)
28849                                                        {
28850                                                          /* 33222222222211111111110000000000
28851                                                             10987654321098765432109876543210
28852                                                             xx0011100x1xxxxx111101xxxxxxxxxx
28853                                                             fmax.  */
28854                                                          return 301;
28855                                                        }
28856                                                      else
28857                                                        {
28858                                                          /* 33222222222211111111110000000000
28859                                                             10987654321098765432109876543210
28860                                                             xx1011100x1xxxxx111101xxxxxxxxxx
28861                                                             fmaxp.  */
28862                                                          return 352;
28863                                                        }
28864                                                    }
28865                                                  else
28866                                                    {
28867                                                      if (((word >> 29) & 0x1) == 0)
28868                                                        {
28869                                                          /* 33222222222211111111110000000000
28870                                                             10987654321098765432109876543210
28871                                                             xx0011101x1xxxxx111101xxxxxxxxxx
28872                                                             fmin.  */
28873                                                          return 313;
28874                                                        }
28875                                                      else
28876                                                        {
28877                                                          /* 33222222222211111111110000000000
28878                                                             10987654321098765432109876543210
28879                                                             xx1011101x1xxxxx111101xxxxxxxxxx
28880                                                             fminp.  */
28881                                                          return 366;
28882                                                        }
28883                                                    }
28884                                                }
28885                                            }
28886                                        }
28887                                    }
28888                                  else
28889                                    {
28890                                      if (((word >> 12) & 0x1) == 0)
28891                                        {
28892                                          if (((word >> 13) & 0x1) == 0)
28893                                            {
28894                                              if (((word >> 14) & 0x1) == 0)
28895                                                {
28896                                                  if (((word >> 29) & 0x1) == 0)
28897                                                    {
28898                                                      if (((word >> 31) & 0x1) == 0)
28899                                                        {
28900                                                          /* 33222222222211111111110000000000
28901                                                             10987654321098765432109876543210
28902                                                             0x001110xx1xxxxx100011xxxxxxxxxx
28903                                                             cmtst.  */
28904                                                          return 284;
28905                                                        }
28906                                                      else
28907                                                        {
28908                                                          /* 33222222222211111111110000000000
28909                                                             10987654321098765432109876543210
28910                                                             1x001110xx1xxxxx100011xxxxxxxxxx
28911                                                             rax1.  */
28912                                                          return 2982;
28913                                                        }
28914                                                    }
28915                                                  else
28916                                                    {
28917                                                      /* 33222222222211111111110000000000
28918                                                         10987654321098765432109876543210
28919                                                         xx101110xx1xxxxx100011xxxxxxxxxx
28920                                                         cmeq.  */
28921                                                      return 336;
28922                                                    }
28923                                                }
28924                                              else
28925                                                {
28926                                                  if (((word >> 23) & 0x1) == 0)
28927                                                    {
28928                                                      if (((word >> 29) & 0x1) == 0)
28929                                                        {
28930                                                          /* 33222222222211111111110000000000
28931                                                             10987654321098765432109876543210
28932                                                             xx0011100x1xxxxx110011xxxxxxxxxx
28933                                                             fmla.  */
28934                                                          return 293;
28935                                                        }
28936                                                      else
28937                                                        {
28938                                                          if (((word >> 30) & 0x1) == 0)
28939                                                            {
28940                                                              /* 33222222222211111111110000000000
28941                                                                 10987654321098765432109876543210
28942                                                                 x01011100x1xxxxx110011xxxxxxxxxx
28943                                                                 fmlal2.  */
28944                                                              return 2996;
28945                                                            }
28946                                                          else
28947                                                            {
28948                                                              /* 33222222222211111111110000000000
28949                                                                 10987654321098765432109876543210
28950                                                                 x11011100x1xxxxx110011xxxxxxxxxx
28951                                                                 fmlal2.  */
28952                                                              return 3000;
28953                                                            }
28954                                                        }
28955                                                    }
28956                                                  else
28957                                                    {
28958                                                      if (((word >> 29) & 0x1) == 0)
28959                                                        {
28960                                                          /* 33222222222211111111110000000000
28961                                                             10987654321098765432109876543210
28962                                                             xx0011101x1xxxxx110011xxxxxxxxxx
28963                                                             fmls.  */
28964                                                          return 309;
28965                                                        }
28966                                                      else
28967                                                        {
28968                                                          if (((word >> 30) & 0x1) == 0)
28969                                                            {
28970                                                              /* 33222222222211111111110000000000
28971                                                                 10987654321098765432109876543210
28972                                                                 x01011101x1xxxxx110011xxxxxxxxxx
28973                                                                 fmlsl2.  */
28974                                                              return 2997;
28975                                                            }
28976                                                          else
28977                                                            {
28978                                                              /* 33222222222211111111110000000000
28979                                                                 10987654321098765432109876543210
28980                                                                 x11011101x1xxxxx110011xxxxxxxxxx
28981                                                                 fmlsl2.  */
28982                                                              return 3001;
28983                                                            }
28984                                                        }
28985                                                    }
28986                                                }
28987                                            }
28988                                          else
28989                                            {
28990                                              if (((word >> 14) & 0x1) == 0)
28991                                                {
28992                                                  if (((word >> 29) & 0x1) == 0)
28993                                                    {
28994                                                      /* 33222222222211111111110000000000
28995                                                         10987654321098765432109876543210
28996                                                         xx001110xx1xxxxx101011xxxxxxxxxx
28997                                                         sminp.  */
28998                                                      return 288;
28999                                                    }
29000                                                  else
29001                                                    {
29002                                                      /* 33222222222211111111110000000000
29003                                                         10987654321098765432109876543210
29004                                                         xx101110xx1xxxxx101011xxxxxxxxxx
29005                                                         uminp.  */
29006                                                      return 340;
29007                                                    }
29008                                                }
29009                                              else
29010                                                {
29011                                                  if (((word >> 23) & 0x1) == 0)
29012                                                    {
29013                                                      if (((word >> 29) & 0x1) == 0)
29014                                                        {
29015                                                          if (((word >> 30) & 0x1) == 0)
29016                                                            {
29017                                                              /* 33222222222211111111110000000000
29018                                                                 10987654321098765432109876543210
29019                                                                 x00011100x1xxxxx111011xxxxxxxxxx
29020                                                                 fmlal.  */
29021                                                              return 2994;
29022                                                            }
29023                                                          else
29024                                                            {
29025                                                              /* 33222222222211111111110000000000
29026                                                                 10987654321098765432109876543210
29027                                                                 x10011100x1xxxxx111011xxxxxxxxxx
29028                                                                 fmlal.  */
29029                                                              return 2998;
29030                                                            }
29031                                                        }
29032                                                      else
29033                                                        {
29034                                                          /* 33222222222211111111110000000000
29035                                                             10987654321098765432109876543210
29036                                                             xx1011100x1xxxxx111011xxxxxxxxxx
29037                                                             facge.  */
29038                                                          return 350;
29039                                                        }
29040                                                    }
29041                                                  else
29042                                                    {
29043                                                      if (((word >> 29) & 0x1) == 0)
29044                                                        {
29045                                                          if (((word >> 30) & 0x1) == 0)
29046                                                            {
29047                                                              /* 33222222222211111111110000000000
29048                                                                 10987654321098765432109876543210
29049                                                                 x00011101x1xxxxx111011xxxxxxxxxx
29050                                                                 fmlsl.  */
29051                                                              return 2995;
29052                                                            }
29053                                                          else
29054                                                            {
29055                                                              /* 33222222222211111111110000000000
29056                                                                 10987654321098765432109876543210
29057                                                                 x10011101x1xxxxx111011xxxxxxxxxx
29058                                                                 fmlsl.  */
29059                                                              return 2999;
29060                                                            }
29061                                                        }
29062                                                      else
29063                                                        {
29064                                                          /* 33222222222211111111110000000000
29065                                                             10987654321098765432109876543210
29066                                                             xx1011101x1xxxxx111011xxxxxxxxxx
29067                                                             facgt.  */
29068                                                          return 364;
29069                                                        }
29070                                                    }
29071                                                }
29072                                            }
29073                                        }
29074                                      else
29075                                        {
29076                                          if (((word >> 13) & 0x1) == 0)
29077                                            {
29078                                              if (((word >> 14) & 0x1) == 0)
29079                                                {
29080                                                  if (((word >> 29) & 0x1) == 0)
29081                                                    {
29082                                                      /* 33222222222211111111110000000000
29083                                                         10987654321098765432109876543210
29084                                                         xx001110xx1xxxxx100111xxxxxxxxxx
29085                                                         mul.  */
29086                                                      return 286;
29087                                                    }
29088                                                  else
29089                                                    {
29090                                                      /* 33222222222211111111110000000000
29091                                                         10987654321098765432109876543210
29092                                                         xx101110xx1xxxxx100111xxxxxxxxxx
29093                                                         pmul.  */
29094                                                      return 338;
29095                                                    }
29096                                                }
29097                                              else
29098                                                {
29099                                                  if (((word >> 29) & 0x1) == 0)
29100                                                    {
29101                                                      /* 33222222222211111111110000000000
29102                                                         10987654321098765432109876543210
29103                                                         xx001110xx1xxxxx110111xxxxxxxxxx
29104                                                         fmulx.  */
29105                                                      return 297;
29106                                                    }
29107                                                  else
29108                                                    {
29109                                                      /* 33222222222211111111110000000000
29110                                                         10987654321098765432109876543210
29111                                                         xx101110xx1xxxxx110111xxxxxxxxxx
29112                                                         fmul.  */
29113                                                      return 346;
29114                                                    }
29115                                                }
29116                                            }
29117                                          else
29118                                            {
29119                                              if (((word >> 14) & 0x1) == 0)
29120                                                {
29121                                                  /* 33222222222211111111110000000000
29122                                                     10987654321098765432109876543210
29123                                                     xxx01110xx1xxxxx101111xxxxxxxxxx
29124                                                     addp.  */
29125                                                  return 290;
29126                                                }
29127                                              else
29128                                                {
29129                                                  if (((word >> 23) & 0x1) == 0)
29130                                                    {
29131                                                      if (((word >> 29) & 0x1) == 0)
29132                                                        {
29133                                                          /* 33222222222211111111110000000000
29134                                                             10987654321098765432109876543210
29135                                                             xx0011100x1xxxxx111111xxxxxxxxxx
29136                                                             frecps.  */
29137                                                          return 303;
29138                                                        }
29139                                                      else
29140                                                        {
29141                                                          /* 33222222222211111111110000000000
29142                                                             10987654321098765432109876543210
29143                                                             xx1011100x1xxxxx111111xxxxxxxxxx
29144                                                             fdiv.  */
29145                                                          return 354;
29146                                                        }
29147                                                    }
29148                                                  else
29149                                                    {
29150                                                      /* 33222222222211111111110000000000
29151                                                         10987654321098765432109876543210
29152                                                         xxx011101x1xxxxx111111xxxxxxxxxx
29153                                                         frsqrts.  */
29154                                                      return 315;
29155                                                    }
29156                                                }
29157                                            }
29158                                        }
29159                                    }
29160                                }
29161                            }
29162                        }
29163                      else
29164                        {
29165                          if (((word >> 10) & 0x1) == 0)
29166                            {
29167                              if (((word >> 11) & 0x1) == 0)
29168                                {
29169                                  if (((word >> 12) & 0x1) == 0)
29170                                    {
29171                                      if (((word >> 13) & 0x1) == 0)
29172                                        {
29173                                          if (((word >> 14) & 0x1) == 0)
29174                                            {
29175                                              if (((word >> 16) & 0x1) == 0)
29176                                                {
29177                                                  if (((word >> 17) & 0x1) == 0)
29178                                                    {
29179                                                      if (((word >> 18) & 0x1) == 0)
29180                                                        {
29181                                                          if (((word >> 19) & 0x1) == 0)
29182                                                            {
29183                                                              if (((word >> 20) & 0x1) == 0)
29184                                                                {
29185                                                                  /* 33222222222211111111110000000000
29186                                                                     10987654321098765432109876543210
29187                                                                     xxx11110xx100000x00000xxxxxxxxxx
29188                                                                     fcvtns.  */
29189                                                                  return 768;
29190                                                                }
29191                                                              else
29192                                                                {
29193                                                                  /* 33222222222211111111110000000000
29194                                                                     10987654321098765432109876543210
29195                                                                     xxx11110xx110000x00000xxxxxxxxxx
29196                                                                     fcvtms.  */
29197                                                                  return 788;
29198                                                                }
29199                                                            }
29200                                                          else
29201                                                            {
29202                                                              if (((word >> 20) & 0x1) == 0)
29203                                                                {
29204                                                                  /* 33222222222211111111110000000000
29205                                                                     10987654321098765432109876543210
29206                                                                     xxx11110xx101000x00000xxxxxxxxxx
29207                                                                     fcvtps.  */
29208                                                                  return 784;
29209                                                                }
29210                                                              else
29211                                                                {
29212                                                                  /* 33222222222211111111110000000000
29213                                                                     10987654321098765432109876543210
29214                                                                     xxx11110xx111000x00000xxxxxxxxxx
29215                                                                     fcvtzs.  */
29216                                                                  return 792;
29217                                                                }
29218                                                            }
29219                                                        }
29220                                                      else
29221                                                        {
29222                                                          /* 33222222222211111111110000000000
29223                                                             10987654321098765432109876543210
29224                                                             xxx11110xx1xx100x00000xxxxxxxxxx
29225                                                             fcvtas.  */
29226                                                          return 776;
29227                                                        }
29228                                                    }
29229                                                  else
29230                                                    {
29231                                                      if (((word >> 18) & 0x1) == 0)
29232                                                        {
29233                                                          /* 33222222222211111111110000000000
29234                                                             10987654321098765432109876543210
29235                                                             xxx11110xx1xx010x00000xxxxxxxxxx
29236                                                             scvtf.  */
29237                                                          return 772;
29238                                                        }
29239                                                      else
29240                                                        {
29241                                                          if (((word >> 19) & 0x1) == 0)
29242                                                            {
29243                                                              /* 33222222222211111111110000000000
29244                                                                 10987654321098765432109876543210
29245                                                                 xxx11110xx1x0110x00000xxxxxxxxxx
29246                                                                 fmov.  */
29247                                                              return 780;
29248                                                            }
29249                                                          else
29250                                                            {
29251                                                              if (((word >> 20) & 0x1) == 0)
29252                                                                {
29253                                                                  /* 33222222222211111111110000000000
29254                                                                     10987654321098765432109876543210
29255                                                                     xxx11110xx101110x00000xxxxxxxxxx
29256                                                                     fmov.  */
29257                                                                  return 796;
29258                                                                }
29259                                                              else
29260                                                                {
29261                                                                  /* 33222222222211111111110000000000
29262                                                                     10987654321098765432109876543210
29263                                                                     xxx11110xx111110x00000xxxxxxxxxx
29264                                                                     fjcvtzs.  */
29265                                                                  return 798;
29266                                                                }
29267                                                            }
29268                                                        }
29269                                                    }
29270                                                }
29271                                              else
29272                                                {
29273                                                  if (((word >> 17) & 0x1) == 0)
29274                                                    {
29275                                                      if (((word >> 18) & 0x1) == 0)
29276                                                        {
29277                                                          if (((word >> 19) & 0x1) == 0)
29278                                                            {
29279                                                              if (((word >> 20) & 0x1) == 0)
29280                                                                {
29281                                                                  /* 33222222222211111111110000000000
29282                                                                     10987654321098765432109876543210
29283                                                                     xxx11110xx100001x00000xxxxxxxxxx
29284                                                                     fcvtnu.  */
29285                                                                  return 770;
29286                                                                }
29287                                                              else
29288                                                                {
29289                                                                  /* 33222222222211111111110000000000
29290                                                                     10987654321098765432109876543210
29291                                                                     xxx11110xx110001x00000xxxxxxxxxx
29292                                                                     fcvtmu.  */
29293                                                                  return 790;
29294                                                                }
29295                                                            }
29296                                                          else
29297                                                            {
29298                                                              if (((word >> 20) & 0x1) == 0)
29299                                                                {
29300                                                                  /* 33222222222211111111110000000000
29301                                                                     10987654321098765432109876543210
29302                                                                     xxx11110xx101001x00000xxxxxxxxxx
29303                                                                     fcvtpu.  */
29304                                                                  return 786;
29305                                                                }
29306                                                              else
29307                                                                {
29308                                                                  /* 33222222222211111111110000000000
29309                                                                     10987654321098765432109876543210
29310                                                                     xxx11110xx111001x00000xxxxxxxxxx
29311                                                                     fcvtzu.  */
29312                                                                  return 794;
29313                                                                }
29314                                                            }
29315                                                        }
29316                                                      else
29317                                                        {
29318                                                          /* 33222222222211111111110000000000
29319                                                             10987654321098765432109876543210
29320                                                             xxx11110xx1xx101x00000xxxxxxxxxx
29321                                                             fcvtau.  */
29322                                                          return 778;
29323                                                        }
29324                                                    }
29325                                                  else
29326                                                    {
29327                                                      if (((word >> 18) & 0x1) == 0)
29328                                                        {
29329                                                          /* 33222222222211111111110000000000
29330                                                             10987654321098765432109876543210
29331                                                             xxx11110xx1xx011x00000xxxxxxxxxx
29332                                                             ucvtf.  */
29333                                                          return 774;
29334                                                        }
29335                                                      else
29336                                                        {
29337                                                          if (((word >> 19) & 0x1) == 0)
29338                                                            {
29339                                                              /* 33222222222211111111110000000000
29340                                                                 10987654321098765432109876543210
29341                                                                 xxx11110xx1x0111x00000xxxxxxxxxx
29342                                                                 fmov.  */
29343                                                              return 782;
29344                                                            }
29345                                                          else
29346                                                            {
29347                                                              /* 33222222222211111111110000000000
29348                                                                 10987654321098765432109876543210
29349                                                                 xxx11110xx1x1111x00000xxxxxxxxxx
29350                                                                 fmov.  */
29351                                                              return 797;
29352                                                            }
29353                                                        }
29354                                                    }
29355                                                }
29356                                            }
29357                                          else
29358                                            {
29359                                              if (((word >> 17) & 0x1) == 0)
29360                                                {
29361                                                  if (((word >> 15) & 0x1) == 0)
29362                                                    {
29363                                                      if (((word >> 16) & 0x1) == 0)
29364                                                        {
29365                                                          if (((word >> 18) & 0x1) == 0)
29366                                                            {
29367                                                              if (((word >> 19) & 0x1) == 0)
29368                                                                {
29369                                                                  /* 33222222222211111111110000000000
29370                                                                     10987654321098765432109876543210
29371                                                                     xxx11110xx1x0000010000xxxxxxxxxx
29372                                                                     fmov.  */
29373                                                                  return 817;
29374                                                                }
29375                                                              else
29376                                                                {
29377                                                                  /* 33222222222211111111110000000000
29378                                                                     10987654321098765432109876543210
29379                                                                     xxx11110xx1x1000010000xxxxxxxxxx
29380                                                                     frint32z.  */
29381                                                                  return 813;
29382                                                                }
29383                                                            }
29384                                                          else
29385                                                            {
29386                                                              /* 33222222222211111111110000000000
29387                                                                 10987654321098765432109876543210
29388                                                                 xxx11110xx1xx100010000xxxxxxxxxx
29389                                                                 frintn.  */
29390                                                              return 826;
29391                                                            }
29392                                                        }
29393                                                      else
29394                                                        {
29395                                                          if (((word >> 18) & 0x1) == 0)
29396                                                            {
29397                                                              if (((word >> 19) & 0x1) == 0)
29398                                                                {
29399                                                                  /* 33222222222211111111110000000000
29400                                                                     10987654321098765432109876543210
29401                                                                     xxx11110xx1x0001010000xxxxxxxxxx
29402                                                                     fneg.  */
29403                                                                  return 821;
29404                                                                }
29405                                                              else
29406                                                                {
29407                                                                  /* 33222222222211111111110000000000
29408                                                                     10987654321098765432109876543210
29409                                                                     xxx11110xx1x1001010000xxxxxxxxxx
29410                                                                     frint64z.  */
29411                                                                  return 815;
29412                                                                }
29413                                                            }
29414                                                          else
29415                                                            {
29416                                                              /* 33222222222211111111110000000000
29417                                                                 10987654321098765432109876543210
29418                                                                 xxx11110xx1xx101010000xxxxxxxxxx
29419                                                                 frintm.  */
29420                                                              return 830;
29421                                                            }
29422                                                        }
29423                                                    }
29424                                                  else
29425                                                    {
29426                                                      if (((word >> 16) & 0x1) == 0)
29427                                                        {
29428                                                          if (((word >> 18) & 0x1) == 0)
29429                                                            {
29430                                                              if (((word >> 19) & 0x1) == 0)
29431                                                                {
29432                                                                  /* 33222222222211111111110000000000
29433                                                                     10987654321098765432109876543210
29434                                                                     xxx11110xx1x0000110000xxxxxxxxxx
29435                                                                     fabs.  */
29436                                                                  return 819;
29437                                                                }
29438                                                              else
29439                                                                {
29440                                                                  /* 33222222222211111111110000000000
29441                                                                     10987654321098765432109876543210
29442                                                                     xxx11110xx1x1000110000xxxxxxxxxx
29443                                                                     frint32x.  */
29444                                                                  return 814;
29445                                                                }
29446                                                            }
29447                                                          else
29448                                                            {
29449                                                              /* 33222222222211111111110000000000
29450                                                                 10987654321098765432109876543210
29451                                                                 xxx11110xx1xx100110000xxxxxxxxxx
29452                                                                 frintp.  */
29453                                                              return 828;
29454                                                            }
29455                                                        }
29456                                                      else
29457                                                        {
29458                                                          if (((word >> 18) & 0x1) == 0)
29459                                                            {
29460                                                              if (((word >> 19) & 0x1) == 0)
29461                                                                {
29462                                                                  /* 33222222222211111111110000000000
29463                                                                     10987654321098765432109876543210
29464                                                                     xxx11110xx1x0001110000xxxxxxxxxx
29465                                                                     fsqrt.  */
29466                                                                  return 823;
29467                                                                }
29468                                                              else
29469                                                                {
29470                                                                  /* 33222222222211111111110000000000
29471                                                                     10987654321098765432109876543210
29472                                                                     xxx11110xx1x1001110000xxxxxxxxxx
29473                                                                     frint64x.  */
29474                                                                  return 816;
29475                                                                }
29476                                                            }
29477                                                          else
29478                                                            {
29479                                                              /* 33222222222211111111110000000000
29480                                                                 10987654321098765432109876543210
29481                                                                 xxx11110xx1xx101110000xxxxxxxxxx
29482                                                                 frintz.  */
29483                                                              return 832;
29484                                                            }
29485                                                        }
29486                                                    }
29487                                                }
29488                                              else
29489                                                {
29490                                                  if (((word >> 18) & 0x1) == 0)
29491                                                    {
29492                                                      /* 33222222222211111111110000000000
29493                                                         10987654321098765432109876543210
29494                                                         xxx11110xx1xx01xx10000xxxxxxxxxx
29495                                                         fcvt.  */
29496                                                      return 825;
29497                                                    }
29498                                                  else
29499                                                    {
29500                                                      if (((word >> 15) & 0x1) == 0)
29501                                                        {
29502                                                          if (((word >> 16) & 0x1) == 0)
29503                                                            {
29504                                                              /* 33222222222211111111110000000000
29505                                                                 10987654321098765432109876543210
29506                                                                 xxx11110xx1xx110010000xxxxxxxxxx
29507                                                                 frinta.  */
29508                                                              return 834;
29509                                                            }
29510                                                          else
29511                                                            {
29512                                                              /* 33222222222211111111110000000000
29513                                                                 10987654321098765432109876543210
29514                                                                 xxx11110xx1xx111010000xxxxxxxxxx
29515                                                                 frintx.  */
29516                                                              return 836;
29517                                                            }
29518                                                        }
29519                                                      else
29520                                                        {
29521                                                          /* 33222222222211111111110000000000
29522                                                             10987654321098765432109876543210
29523                                                             xxx11110xx1xx11x110000xxxxxxxxxx
29524                                                             frinti.  */
29525                                                          return 838;
29526                                                        }
29527                                                    }
29528                                                }
29529                                            }
29530                                        }
29531                                      else
29532                                        {
29533                                          if (((word >> 3) & 0x1) == 0)
29534                                            {
29535                                              if (((word >> 4) & 0x1) == 0)
29536                                                {
29537                                                  /* 33222222222211111111110000000000
29538                                                     10987654321098765432109876543210
29539                                                     xxx11110xx1xxxxxxx1000xxxxx00xxx
29540                                                     fcmp.  */
29541                                                  return 803;
29542                                                }
29543                                              else
29544                                                {
29545                                                  /* 33222222222211111111110000000000
29546                                                     10987654321098765432109876543210
29547                                                     xxx11110xx1xxxxxxx1000xxxxx10xxx
29548                                                     fcmpe.  */
29549                                                  return 805;
29550                                                }
29551                                            }
29552                                          else
29553                                            {
29554                                              if (((word >> 4) & 0x1) == 0)
29555                                                {
29556                                                  /* 33222222222211111111110000000000
29557                                                     10987654321098765432109876543210
29558                                                     xxx11110xx1xxxxxxx1000xxxxx01xxx
29559                                                     fcmp.  */
29560                                                  return 807;
29561                                                }
29562                                              else
29563                                                {
29564                                                  /* 33222222222211111111110000000000
29565                                                     10987654321098765432109876543210
29566                                                     xxx11110xx1xxxxxxx1000xxxxx11xxx
29567                                                     fcmpe.  */
29568                                                  return 809;
29569                                                }
29570                                            }
29571                                        }
29572                                    }
29573                                  else
29574                                    {
29575                                      if (((word >> 30) & 0x1) == 0)
29576                                        {
29577                                          /* 33222222222211111111110000000000
29578                                             10987654321098765432109876543210
29579                                             x0x11110xx1xxxxxxxx100xxxxxxxxxx
29580                                             fmov.  */
29581                                          return 866;
29582                                        }
29583                                      else
29584                                        {
29585                                          if (((word >> 13) & 0x1) == 0)
29586                                            {
29587                                              if (((word >> 14) & 0x1) == 0)
29588                                                {
29589                                                  /* 33222222222211111111110000000000
29590                                                     10987654321098765432109876543210
29591                                                     x1x11110xx1xxxxxx00100xxxxxxxxxx
29592                                                     sqdmlal.  */
29593                                                  return 422;
29594                                                }
29595                                              else
29596                                                {
29597                                                  /* 33222222222211111111110000000000
29598                                                     10987654321098765432109876543210
29599                                                     x1x11110xx1xxxxxx10100xxxxxxxxxx
29600                                                     sqdmull.  */
29601                                                  return 424;
29602                                                }
29603                                            }
29604                                          else
29605                                            {
29606                                              /* 33222222222211111111110000000000
29607                                                 10987654321098765432109876543210
29608                                                 x1x11110xx1xxxxxxx1100xxxxxxxxxx
29609                                                 sqdmlsl.  */
29610                                              return 423;
29611                                            }
29612                                        }
29613                                    }
29614                                }
29615                              else
29616                                {
29617                                  if (((word >> 12) & 0x1) == 0)
29618                                    {
29619                                      if (((word >> 13) & 0x1) == 0)
29620                                        {
29621                                          if (((word >> 14) & 0x1) == 0)
29622                                            {
29623                                              if (((word >> 15) & 0x1) == 0)
29624                                                {
29625                                                  if (((word >> 30) & 0x1) == 0)
29626                                                    {
29627                                                      /* 33222222222211111111110000000000
29628                                                         10987654321098765432109876543210
29629                                                         x0x11110xx1xxxxx000010xxxxxxxxxx
29630                                                         fmul.  */
29631                                                      return 840;
29632                                                    }
29633                                                  else
29634                                                    {
29635                                                      /* 33222222222211111111110000000000
29636                                                         10987654321098765432109876543210
29637                                                         x1x11110xx1xxxxx000010xxxxxxxxxx
29638                                                         sha1h.  */
29639                                                      return 675;
29640                                                    }
29641                                                }
29642                                              else
29643                                                {
29644                                                  if (((word >> 29) & 0x1) == 0)
29645                                                    {
29646                                                      if (((word >> 30) & 0x1) == 0)
29647                                                        {
29648                                                          /* 33222222222211111111110000000000
29649                                                             10987654321098765432109876543210
29650                                                             x0011110xx1xxxxx100010xxxxxxxxxx
29651                                                             fnmul.  */
29652                                                          return 856;
29653                                                        }
29654                                                      else
29655                                                        {
29656                                                          /* 33222222222211111111110000000000
29657                                                             10987654321098765432109876543210
29658                                                             x1011110xx1xxxxx100010xxxxxxxxxx
29659                                                             cmgt.  */
29660                                                          return 482;
29661                                                        }
29662                                                    }
29663                                                  else
29664                                                    {
29665                                                      /* 33222222222211111111110000000000
29666                                                         10987654321098765432109876543210
29667                                                         xx111110xx1xxxxx100010xxxxxxxxxx
29668                                                         cmge.  */
29669                                                      return 511;
29670                                                    }
29671                                                }
29672                                            }
29673                                          else
29674                                            {
29675                                              if (((word >> 15) & 0x1) == 0)
29676                                                {
29677                                                  if (((word >> 29) & 0x1) == 0)
29678                                                    {
29679                                                      if (((word >> 30) & 0x1) == 0)
29680                                                        {
29681                                                          /* 33222222222211111111110000000000
29682                                                             10987654321098765432109876543210
29683                                                             x0011110xx1xxxxx010010xxxxxxxxxx
29684                                                             fmax.  */
29685                                                          return 848;
29686                                                        }
29687                                                      else
29688                                                        {
29689                                                          /* 33222222222211111111110000000000
29690                                                             10987654321098765432109876543210
29691                                                             x1011110xx1xxxxx010010xxxxxxxxxx
29692                                                             sqxtn.  */
29693                                                          return 486;
29694                                                        }
29695                                                    }
29696                                                  else
29697                                                    {
29698                                                      /* 33222222222211111111110000000000
29699                                                         10987654321098765432109876543210
29700                                                         xx111110xx1xxxxx010010xxxxxxxxxx
29701                                                         uqxtn.  */
29702                                                      return 515;
29703                                                    }
29704                                                }
29705                                              else
29706                                                {
29707                                                  if (((word >> 16) & 0x1) == 0)
29708                                                    {
29709                                                      if (((word >> 19) & 0x1) == 0)
29710                                                        {
29711                                                          if (((word >> 20) & 0x1) == 0)
29712                                                            {
29713                                                              if (((word >> 29) & 0x1) == 0)
29714                                                                {
29715                                                                  /* 33222222222211111111110000000000
29716                                                                     10987654321098765432109876543210
29717                                                                     xx011110xx100xx0110010xxxxxxxxxx
29718                                                                     fcmgt.  */
29719                                                                  return 495;
29720                                                                }
29721                                                              else
29722                                                                {
29723                                                                  /* 33222222222211111111110000000000
29724                                                                     10987654321098765432109876543210
29725                                                                     xx111110xx100xx0110010xxxxxxxxxx
29726                                                                     fcmge.  */
29727                                                                  return 525;
29728                                                                }
29729                                                            }
29730                                                          else
29731                                                            {
29732                                                              if (((word >> 23) & 0x1) == 0)
29733                                                                {
29734                                                                  if (((word >> 29) & 0x1) == 0)
29735                                                                    {
29736                                                                      /* 33222222222211111111110000000000
29737                                                                         10987654321098765432109876543210
29738                                                                         xx0111100x110xx0110010xxxxxxxxxx
29739                                                                         fmaxnmp.  */
29740                                                                      return 539;
29741                                                                    }
29742                                                                  else
29743                                                                    {
29744                                                                      /* 33222222222211111111110000000000
29745                                                                         10987654321098765432109876543210
29746                                                                         xx1111100x110xx0110010xxxxxxxxxx
29747                                                                         fmaxnmp.  */
29748                                                                      return 538;
29749                                                                    }
29750                                                                }
29751                                                              else
29752                                                                {
29753                                                                  if (((word >> 29) & 0x1) == 0)
29754                                                                    {
29755                                                                      /* 33222222222211111111110000000000
29756                                                                         10987654321098765432109876543210
29757                                                                         xx0111101x110xx0110010xxxxxxxxxx
29758                                                                         fminnmp.  */
29759                                                                      return 545;
29760                                                                    }
29761                                                                  else
29762                                                                    {
29763                                                                      /* 33222222222211111111110000000000
29764                                                                         10987654321098765432109876543210
29765                                                                         xx1111101x110xx0110010xxxxxxxxxx
29766                                                                         fminnmp.  */
29767                                                                      return 544;
29768                                                                    }
29769                                                                }
29770                                                            }
29771                                                        }
29772                                                      else
29773                                                        {
29774                                                          if (((word >> 29) & 0x1) == 0)
29775                                                            {
29776                                                              /* 33222222222211111111110000000000
29777                                                                 10987654321098765432109876543210
29778                                                                 xx011110xx1x1xx0110010xxxxxxxxxx
29779                                                                 fcmgt.  */
29780                                                              return 496;
29781                                                            }
29782                                                          else
29783                                                            {
29784                                                              /* 33222222222211111111110000000000
29785                                                                 10987654321098765432109876543210
29786                                                                 xx111110xx1x1xx0110010xxxxxxxxxx
29787                                                                 fcmge.  */
29788                                                              return 526;
29789                                                            }
29790                                                        }
29791                                                    }
29792                                                  else
29793                                                    {
29794                                                      if (((word >> 19) & 0x1) == 0)
29795                                                        {
29796                                                          if (((word >> 29) & 0x1) == 0)
29797                                                            {
29798                                                              /* 33222222222211111111110000000000
29799                                                                 10987654321098765432109876543210
29800                                                                 xx011110xx1x0xx1110010xxxxxxxxxx
29801                                                                 fcvtas.  */
29802                                                              return 491;
29803                                                            }
29804                                                          else
29805                                                            {
29806                                                              /* 33222222222211111111110000000000
29807                                                                 10987654321098765432109876543210
29808                                                                 xx111110xx1x0xx1110010xxxxxxxxxx
29809                                                                 fcvtau.  */
29810                                                              return 521;
29811                                                            }
29812                                                        }
29813                                                      else
29814                                                        {
29815                                                          if (((word >> 29) & 0x1) == 0)
29816                                                            {
29817                                                              /* 33222222222211111111110000000000
29818                                                                 10987654321098765432109876543210
29819                                                                 xx011110xx1x1xx1110010xxxxxxxxxx
29820                                                                 fcvtas.  */
29821                                                              return 492;
29822                                                            }
29823                                                          else
29824                                                            {
29825                                                              /* 33222222222211111111110000000000
29826                                                                 10987654321098765432109876543210
29827                                                                 xx111110xx1x1xx1110010xxxxxxxxxx
29828                                                                 fcvtau.  */
29829                                                              return 522;
29830                                                            }
29831                                                        }
29832                                                    }
29833                                                }
29834                                            }
29835                                        }
29836                                      else
29837                                        {
29838                                          if (((word >> 14) & 0x1) == 0)
29839                                            {
29840                                              if (((word >> 15) & 0x1) == 0)
29841                                                {
29842                                                  if (((word >> 29) & 0x1) == 0)
29843                                                    {
29844                                                      if (((word >> 30) & 0x1) == 0)
29845                                                        {
29846                                                          /* 33222222222211111111110000000000
29847                                                             10987654321098765432109876543210
29848                                                             x0011110xx1xxxxx001010xxxxxxxxxx
29849                                                             fadd.  */
29850                                                          return 844;
29851                                                        }
29852                                                      else
29853                                                        {
29854                                                          /* 33222222222211111111110000000000
29855                                                             10987654321098765432109876543210
29856                                                             x1011110xx1xxxxx001010xxxxxxxxxx
29857                                                             sha256su0.  */
29858                                                          return 677;
29859                                                        }
29860                                                    }
29861                                                  else
29862                                                    {
29863                                                      /* 33222222222211111111110000000000
29864                                                         10987654321098765432109876543210
29865                                                         xx111110xx1xxxxx001010xxxxxxxxxx
29866                                                         sqxtun.  */
29867                                                      return 514;
29868                                                    }
29869                                                }
29870                                              else
29871                                                {
29872                                                  if (((word >> 16) & 0x1) == 0)
29873                                                    {
29874                                                      /* 33222222222211111111110000000000
29875                                                         10987654321098765432109876543210
29876                                                         xxx11110xx1xxxx0101010xxxxxxxxxx
29877                                                         cmlt.  */
29878                                                      return 484;
29879                                                    }
29880                                                  else
29881                                                    {
29882                                                      if (((word >> 19) & 0x1) == 0)
29883                                                        {
29884                                                          if (((word >> 23) & 0x1) == 0)
29885                                                            {
29886                                                              if (((word >> 29) & 0x1) == 0)
29887                                                                {
29888                                                                  /* 33222222222211111111110000000000
29889                                                                     10987654321098765432109876543210
29890                                                                     xx0111100x1x0xx1101010xxxxxxxxxx
29891                                                                     fcvtns.  */
29892                                                                  return 487;
29893                                                                }
29894                                                              else
29895                                                                {
29896                                                                  /* 33222222222211111111110000000000
29897                                                                     10987654321098765432109876543210
29898                                                                     xx1111100x1x0xx1101010xxxxxxxxxx
29899                                                                     fcvtnu.  */
29900                                                                  return 517;
29901                                                                }
29902                                                            }
29903                                                          else
29904                                                            {
29905                                                              if (((word >> 29) & 0x1) == 0)
29906                                                                {
29907                                                                  /* 33222222222211111111110000000000
29908                                                                     10987654321098765432109876543210
29909                                                                     xx0111101x1x0xx1101010xxxxxxxxxx
29910                                                                     fcvtps.  */
29911                                                                  return 501;
29912                                                                }
29913                                                              else
29914                                                                {
29915                                                                  /* 33222222222211111111110000000000
29916                                                                     10987654321098765432109876543210
29917                                                                     xx1111101x1x0xx1101010xxxxxxxxxx
29918                                                                     fcvtpu.  */
29919                                                                  return 529;
29920                                                                }
29921                                                            }
29922                                                        }
29923                                                      else
29924                                                        {
29925                                                          if (((word >> 23) & 0x1) == 0)
29926                                                            {
29927                                                              if (((word >> 29) & 0x1) == 0)
29928                                                                {
29929                                                                  /* 33222222222211111111110000000000
29930                                                                     10987654321098765432109876543210
29931                                                                     xx0111100x1x1xx1101010xxxxxxxxxx
29932                                                                     fcvtns.  */
29933                                                                  return 488;
29934                                                                }
29935                                                              else
29936                                                                {
29937                                                                  /* 33222222222211111111110000000000
29938                                                                     10987654321098765432109876543210
29939                                                                     xx1111100x1x1xx1101010xxxxxxxxxx
29940                                                                     fcvtnu.  */
29941                                                                  return 518;
29942                                                                }
29943                                                            }
29944                                                          else
29945                                                            {
29946                                                              if (((word >> 29) & 0x1) == 0)
29947                                                                {
29948                                                                  /* 33222222222211111111110000000000
29949                                                                     10987654321098765432109876543210
29950                                                                     xx0111101x1x1xx1101010xxxxxxxxxx
29951                                                                     fcvtps.  */
29952                                                                  return 502;
29953                                                                }
29954                                                              else
29955                                                                {
29956                                                                  /* 33222222222211111111110000000000
29957                                                                     10987654321098765432109876543210
29958                                                                     xx1111101x1x1xx1101010xxxxxxxxxx
29959                                                                     fcvtpu.  */
29960                                                                  return 530;
29961                                                                }
29962                                                            }
29963                                                        }
29964                                                    }
29965                                                }
29966                                            }
29967                                          else
29968                                            {
29969                                              if (((word >> 15) & 0x1) == 0)
29970                                                {
29971                                                  if (((word >> 29) & 0x1) == 0)
29972                                                    {
29973                                                      /* 33222222222211111111110000000000
29974                                                         10987654321098765432109876543210
29975                                                         xx011110xx1xxxxx011010xxxxxxxxxx
29976                                                         fmaxnm.  */
29977                                                      return 852;
29978                                                    }
29979                                                  else
29980                                                    {
29981                                                      /* 33222222222211111111110000000000
29982                                                         10987654321098765432109876543210
29983                                                         xx111110xx1xxxxx011010xxxxxxxxxx
29984                                                         fcvtxn.  */
29985                                                      return 516;
29986                                                    }
29987                                                }
29988                                              else
29989                                                {
29990                                                  if (((word >> 19) & 0x1) == 0)
29991                                                    {
29992                                                      /* 33222222222211111111110000000000
29993                                                         10987654321098765432109876543210
29994                                                         xxx11110xx1x0xxx111010xxxxxxxxxx
29995                                                         fcmlt.  */
29996                                                      return 499;
29997                                                    }
29998                                                  else
29999                                                    {
30000                                                      /* 33222222222211111111110000000000
30001                                                         10987654321098765432109876543210
30002                                                         xxx11110xx1x1xxx111010xxxxxxxxxx
30003                                                         fcmlt.  */
30004                                                      return 500;
30005                                                    }
30006                                                }
30007                                            }
30008                                        }
30009                                    }
30010                                  else
30011                                    {
30012                                      if (((word >> 13) & 0x1) == 0)
30013                                        {
30014                                          if (((word >> 14) & 0x1) == 0)
30015                                            {
30016                                              if (((word >> 15) & 0x1) == 0)
30017                                                {
30018                                                  if (((word >> 30) & 0x1) == 0)
30019                                                    {
30020                                                      /* 33222222222211111111110000000000
30021                                                         10987654321098765432109876543210
30022                                                         x0x11110xx1xxxxx000110xxxxxxxxxx
30023                                                         fdiv.  */
30024                                                      return 842;
30025                                                    }
30026                                                  else
30027                                                    {
30028                                                      /* 33222222222211111111110000000000
30029                                                         10987654321098765432109876543210
30030                                                         x1x11110xx1xxxxx000110xxxxxxxxxx
30031                                                         sha1su1.  */
30032                                                      return 676;
30033                                                    }
30034                                                }
30035                                              else
30036                                                {
30037                                                  if (((word >> 29) & 0x1) == 0)
30038                                                    {
30039                                                      /* 33222222222211111111110000000000
30040                                                         10987654321098765432109876543210
30041                                                         xx011110xx1xxxxx100110xxxxxxxxxx
30042                                                         cmeq.  */
30043                                                      return 483;
30044                                                    }
30045                                                  else
30046                                                    {
30047                                                      /* 33222222222211111111110000000000
30048                                                         10987654321098765432109876543210
30049                                                         xx111110xx1xxxxx100110xxxxxxxxxx
30050                                                         cmle.  */
30051                                                      return 512;
30052                                                    }
30053                                                }
30054                                            }
30055                                          else
30056                                            {
30057                                              if (((word >> 15) & 0x1) == 0)
30058                                                {
30059                                                  /* 33222222222211111111110000000000
30060                                                     10987654321098765432109876543210
30061                                                     xxx11110xx1xxxxx010110xxxxxxxxxx
30062                                                     fmin.  */
30063                                                  return 850;
30064                                                }
30065                                              else
30066                                                {
30067                                                  if (((word >> 16) & 0x1) == 0)
30068                                                    {
30069                                                      if (((word >> 19) & 0x1) == 0)
30070                                                        {
30071                                                          if (((word >> 20) & 0x1) == 0)
30072                                                            {
30073                                                              if (((word >> 29) & 0x1) == 0)
30074                                                                {
30075                                                                  /* 33222222222211111111110000000000
30076                                                                     10987654321098765432109876543210
30077                                                                     xx011110xx100xx0110110xxxxxxxxxx
30078                                                                     fcmeq.  */
30079                                                                  return 497;
30080                                                                }
30081                                                              else
30082                                                                {
30083                                                                  /* 33222222222211111111110000000000
30084                                                                     10987654321098765432109876543210
30085                                                                     xx111110xx100xx0110110xxxxxxxxxx
30086                                                                     fcmle.  */
30087                                                                  return 527;
30088                                                                }
30089                                                            }
30090                                                          else
30091                                                            {
30092                                                              if (((word >> 29) & 0x1) == 0)
30093                                                                {
30094                                                                  /* 33222222222211111111110000000000
30095                                                                     10987654321098765432109876543210
30096                                                                     xx011110xx110xx0110110xxxxxxxxxx
30097                                                                     faddp.  */
30098                                                                  return 541;
30099                                                                }
30100                                                              else
30101                                                                {
30102                                                                  /* 33222222222211111111110000000000
30103                                                                     10987654321098765432109876543210
30104                                                                     xx111110xx110xx0110110xxxxxxxxxx
30105                                                                     faddp.  */
30106                                                                  return 540;
30107                                                                }
30108                                                            }
30109                                                        }
30110                                                      else
30111                                                        {
30112                                                          if (((word >> 29) & 0x1) == 0)
30113                                                            {
30114                                                              /* 33222222222211111111110000000000
30115                                                                 10987654321098765432109876543210
30116                                                                 xx011110xx1x1xx0110110xxxxxxxxxx
30117                                                                 fcmeq.  */
30118                                                              return 498;
30119                                                            }
30120                                                          else
30121                                                            {
30122                                                              /* 33222222222211111111110000000000
30123                                                                 10987654321098765432109876543210
30124                                                                 xx111110xx1x1xx0110110xxxxxxxxxx
30125                                                                 fcmle.  */
30126                                                              return 528;
30127                                                            }
30128                                                        }
30129                                                    }
30130                                                  else
30131                                                    {
30132                                                      if (((word >> 19) & 0x1) == 0)
30133                                                        {
30134                                                          if (((word >> 23) & 0x1) == 0)
30135                                                            {
30136                                                              if (((word >> 29) & 0x1) == 0)
30137                                                                {
30138                                                                  /* 33222222222211111111110000000000
30139                                                                     10987654321098765432109876543210
30140                                                                     xx0111100x1x0xx1110110xxxxxxxxxx
30141                                                                     scvtf.  */
30142                                                                  return 493;
30143                                                                }
30144                                                              else
30145                                                                {
30146                                                                  /* 33222222222211111111110000000000
30147                                                                     10987654321098765432109876543210
30148                                                                     xx1111100x1x0xx1110110xxxxxxxxxx
30149                                                                     ucvtf.  */
30150                                                                  return 523;
30151                                                                }
30152                                                            }
30153                                                          else
30154                                                            {
30155                                                              if (((word >> 29) & 0x1) == 0)
30156                                                                {
30157                                                                  /* 33222222222211111111110000000000
30158                                                                     10987654321098765432109876543210
30159                                                                     xx0111101x1x0xx1110110xxxxxxxxxx
30160                                                                     frecpe.  */
30161                                                                  return 505;
30162                                                                }
30163                                                              else
30164                                                                {
30165                                                                  /* 33222222222211111111110000000000
30166                                                                     10987654321098765432109876543210
30167                                                                     xx1111101x1x0xx1110110xxxxxxxxxx
30168                                                                     frsqrte.  */
30169                                                                  return 533;
30170                                                                }
30171                                                            }
30172                                                        }
30173                                                      else
30174                                                        {
30175                                                          if (((word >> 23) & 0x1) == 0)
30176                                                            {
30177                                                              if (((word >> 29) & 0x1) == 0)
30178                                                                {
30179                                                                  /* 33222222222211111111110000000000
30180                                                                     10987654321098765432109876543210
30181                                                                     xx0111100x1x1xx1110110xxxxxxxxxx
30182                                                                     scvtf.  */
30183                                                                  return 494;
30184                                                                }
30185                                                              else
30186                                                                {
30187                                                                  /* 33222222222211111111110000000000
30188                                                                     10987654321098765432109876543210
30189                                                                     xx1111100x1x1xx1110110xxxxxxxxxx
30190                                                                     ucvtf.  */
30191                                                                  return 524;
30192                                                                }
30193                                                            }
30194                                                          else
30195                                                            {
30196                                                              if (((word >> 29) & 0x1) == 0)
30197                                                                {
30198                                                                  /* 33222222222211111111110000000000
30199                                                                     10987654321098765432109876543210
30200                                                                     xx0111101x1x1xx1110110xxxxxxxxxx
30201                                                                     frecpe.  */
30202                                                                  return 506;
30203                                                                }
30204                                                              else
30205                                                                {
30206                                                                  /* 33222222222211111111110000000000
30207                                                                     10987654321098765432109876543210
30208                                                                     xx1111101x1x1xx1110110xxxxxxxxxx
30209                                                                     frsqrte.  */
30210                                                                  return 534;
30211                                                                }
30212                                                            }
30213                                                        }
30214                                                    }
30215                                                }
30216                                            }
30217                                        }
30218                                      else
30219                                        {
30220                                          if (((word >> 14) & 0x1) == 0)
30221                                            {
30222                                              if (((word >> 15) & 0x1) == 0)
30223                                                {
30224                                                  if (((word >> 29) & 0x1) == 0)
30225                                                    {
30226                                                      if (((word >> 30) & 0x1) == 0)
30227                                                        {
30228                                                          /* 33222222222211111111110000000000
30229                                                             10987654321098765432109876543210
30230                                                             x0011110xx1xxxxx001110xxxxxxxxxx
30231                                                             fsub.  */
30232                                                          return 846;
30233                                                        }
30234                                                      else
30235                                                        {
30236                                                          /* 33222222222211111111110000000000
30237                                                             10987654321098765432109876543210
30238                                                             x1011110xx1xxxxx001110xxxxxxxxxx
30239                                                             suqadd.  */
30240                                                          return 480;
30241                                                        }
30242                                                    }
30243                                                  else
30244                                                    {
30245                                                      /* 33222222222211111111110000000000
30246                                                         10987654321098765432109876543210
30247                                                         xx111110xx1xxxxx001110xxxxxxxxxx
30248                                                         usqadd.  */
30249                                                      return 509;
30250                                                    }
30251                                                }
30252                                              else
30253                                                {
30254                                                  if (((word >> 16) & 0x1) == 0)
30255                                                    {
30256                                                      if (((word >> 29) & 0x1) == 0)
30257                                                        {
30258                                                          /* 33222222222211111111110000000000
30259                                                             10987654321098765432109876543210
30260                                                             xx011110xx1xxxx0101110xxxxxxxxxx
30261                                                             abs.  */
30262                                                          return 485;
30263                                                        }
30264                                                      else
30265                                                        {
30266                                                          /* 33222222222211111111110000000000
30267                                                             10987654321098765432109876543210
30268                                                             xx111110xx1xxxx0101110xxxxxxxxxx
30269                                                             neg.  */
30270                                                          return 513;
30271                                                        }
30272                                                    }
30273                                                  else
30274                                                    {
30275                                                      if (((word >> 19) & 0x1) == 0)
30276                                                        {
30277                                                          if (((word >> 20) & 0x1) == 0)
30278                                                            {
30279                                                              if (((word >> 23) & 0x1) == 0)
30280                                                                {
30281                                                                  if (((word >> 29) & 0x1) == 0)
30282                                                                    {
30283                                                                      /* 33222222222211111111110000000000
30284                                                                         10987654321098765432109876543210
30285                                                                         xx0111100x100xx1101110xxxxxxxxxx
30286                                                                         fcvtms.  */
30287                                                                      return 489;
30288                                                                    }
30289                                                                  else
30290                                                                    {
30291                                                                      /* 33222222222211111111110000000000
30292                                                                         10987654321098765432109876543210
30293                                                                         xx1111100x100xx1101110xxxxxxxxxx
30294                                                                         fcvtmu.  */
30295                                                                      return 519;
30296                                                                    }
30297                                                                }
30298                                                              else
30299                                                                {
30300                                                                  if (((word >> 29) & 0x1) == 0)
30301                                                                    {
30302                                                                      /* 33222222222211111111110000000000
30303                                                                         10987654321098765432109876543210
30304                                                                         xx0111101x100xx1101110xxxxxxxxxx
30305                                                                         fcvtzs.  */
30306                                                                      return 503;
30307                                                                    }
30308                                                                  else
30309                                                                    {
30310                                                                      /* 33222222222211111111110000000000
30311                                                                         10987654321098765432109876543210
30312                                                                         xx1111101x100xx1101110xxxxxxxxxx
30313                                                                         fcvtzu.  */
30314                                                                      return 531;
30315                                                                    }
30316                                                                }
30317                                                            }
30318                                                          else
30319                                                            {
30320                                                              /* 33222222222211111111110000000000
30321                                                                 10987654321098765432109876543210
30322                                                                 xxx11110xx110xx1101110xxxxxxxxxx
30323                                                                 addp.  */
30324                                                              return 537;
30325                                                            }
30326                                                        }
30327                                                      else
30328                                                        {
30329                                                          if (((word >> 23) & 0x1) == 0)
30330                                                            {
30331                                                              if (((word >> 29) & 0x1) == 0)
30332                                                                {
30333                                                                  /* 33222222222211111111110000000000
30334                                                                     10987654321098765432109876543210
30335                                                                     xx0111100x1x1xx1101110xxxxxxxxxx
30336                                                                     fcvtms.  */
30337                                                                  return 490;
30338                                                                }
30339                                                              else
30340                                                                {
30341                                                                  /* 33222222222211111111110000000000
30342                                                                     10987654321098765432109876543210
30343                                                                     xx1111100x1x1xx1101110xxxxxxxxxx
30344                                                                     fcvtmu.  */
30345                                                                  return 520;
30346                                                                }
30347                                                            }
30348                                                          else
30349                                                            {
30350                                                              if (((word >> 29) & 0x1) == 0)
30351                                                                {
30352                                                                  /* 33222222222211111111110000000000
30353                                                                     10987654321098765432109876543210
30354                                                                     xx0111101x1x1xx1101110xxxxxxxxxx
30355                                                                     fcvtzs.  */
30356                                                                  return 504;
30357                                                                }
30358                                                              else
30359                                                                {
30360                                                                  /* 33222222222211111111110000000000
30361                                                                     10987654321098765432109876543210
30362                                                                     xx1111101x1x1xx1101110xxxxxxxxxx
30363                                                                     fcvtzu.  */
30364                                                                  return 532;
30365                                                                }
30366                                                            }
30367                                                        }
30368                                                    }
30369                                                }
30370                                            }
30371                                          else
30372                                            {
30373                                              if (((word >> 15) & 0x1) == 0)
30374                                                {
30375                                                  if (((word >> 29) & 0x1) == 0)
30376                                                    {
30377                                                      if (((word >> 30) & 0x1) == 0)
30378                                                        {
30379                                                          /* 33222222222211111111110000000000
30380                                                             10987654321098765432109876543210
30381                                                             x0011110xx1xxxxx011110xxxxxxxxxx
30382                                                             fminnm.  */
30383                                                          return 854;
30384                                                        }
30385                                                      else
30386                                                        {
30387                                                          /* 33222222222211111111110000000000
30388                                                             10987654321098765432109876543210
30389                                                             x1011110xx1xxxxx011110xxxxxxxxxx
30390                                                             sqabs.  */
30391                                                          return 481;
30392                                                        }
30393                                                    }
30394                                                  else
30395                                                    {
30396                                                      /* 33222222222211111111110000000000
30397                                                         10987654321098765432109876543210
30398                                                         xx111110xx1xxxxx011110xxxxxxxxxx
30399                                                         sqneg.  */
30400                                                      return 510;
30401                                                    }
30402                                                }
30403                                              else
30404                                                {
30405                                                  if (((word >> 16) & 0x1) == 0)
30406                                                    {
30407                                                      if (((word >> 23) & 0x1) == 0)
30408                                                        {
30409                                                          if (((word >> 29) & 0x1) == 0)
30410                                                            {
30411                                                              /* 33222222222211111111110000000000
30412                                                                 10987654321098765432109876543210
30413                                                                 xx0111100x1xxxx0111110xxxxxxxxxx
30414                                                                 fmaxp.  */
30415                                                              return 543;
30416                                                            }
30417                                                          else
30418                                                            {
30419                                                              /* 33222222222211111111110000000000
30420                                                                 10987654321098765432109876543210
30421                                                                 xx1111100x1xxxx0111110xxxxxxxxxx
30422                                                                 fmaxp.  */
30423                                                              return 542;
30424                                                            }
30425                                                        }
30426                                                      else
30427                                                        {
30428                                                          if (((word >> 29) & 0x1) == 0)
30429                                                            {
30430                                                              /* 33222222222211111111110000000000
30431                                                                 10987654321098765432109876543210
30432                                                                 xx0111101x1xxxx0111110xxxxxxxxxx
30433                                                                 fminp.  */
30434                                                              return 547;
30435                                                            }
30436                                                          else
30437                                                            {
30438                                                              /* 33222222222211111111110000000000
30439                                                                 10987654321098765432109876543210
30440                                                                 xx1111101x1xxxx0111110xxxxxxxxxx
30441                                                                 fminp.  */
30442                                                              return 546;
30443                                                            }
30444                                                        }
30445                                                    }
30446                                                  else
30447                                                    {
30448                                                      if (((word >> 19) & 0x1) == 0)
30449                                                        {
30450                                                          /* 33222222222211111111110000000000
30451                                                             10987654321098765432109876543210
30452                                                             xxx11110xx1x0xx1111110xxxxxxxxxx
30453                                                             frecpx.  */
30454                                                          return 507;
30455                                                        }
30456                                                      else
30457                                                        {
30458                                                          /* 33222222222211111111110000000000
30459                                                             10987654321098765432109876543210
30460                                                             xxx11110xx1x1xx1111110xxxxxxxxxx
30461                                                             frecpx.  */
30462                                                          return 508;
30463                                                        }
30464                                                    }
30465                                                }
30466                                            }
30467                                        }
30468                                    }
30469                                }
30470                            }
30471                          else
30472                            {
30473                              if (((word >> 11) & 0x1) == 0)
30474                                {
30475                                  if (((word >> 29) & 0x1) == 0)
30476                                    {
30477                                      if (((word >> 30) & 0x1) == 0)
30478                                        {
30479                                          if (((word >> 4) & 0x1) == 0)
30480                                            {
30481                                              /* 33222222222211111111110000000000
30482                                                 10987654321098765432109876543210
30483                                                 x0011110xx1xxxxxxxxx01xxxxx0xxxx
30484                                                 fccmp.  */
30485                                              return 799;
30486                                            }
30487                                          else
30488                                            {
30489                                              /* 33222222222211111111110000000000
30490                                                 10987654321098765432109876543210
30491                                                 x0011110xx1xxxxxxxxx01xxxxx1xxxx
30492                                                 fccmpe.  */
30493                                              return 801;
30494                                            }
30495                                        }
30496                                      else
30497                                        {
30498                                          if (((word >> 12) & 0x1) == 0)
30499                                            {
30500                                              if (((word >> 13) & 0x1) == 0)
30501                                                {
30502                                                  if (((word >> 14) & 0x1) == 0)
30503                                                    {
30504                                                      /* 33222222222211111111110000000000
30505                                                         10987654321098765432109876543210
30506                                                         x1011110xx1xxxxxx00001xxxxxxxxxx
30507                                                         add.  */
30508                                                      return 565;
30509                                                    }
30510                                                  else
30511                                                    {
30512                                                      /* 33222222222211111111110000000000
30513                                                         10987654321098765432109876543210
30514                                                         x1011110xx1xxxxxx10001xxxxxxxxxx
30515                                                         sshl.  */
30516                                                      return 563;
30517                                                    }
30518                                                }
30519                                              else
30520                                                {
30521                                                  /* 33222222222211111111110000000000
30522                                                     10987654321098765432109876543210
30523                                                     x1011110xx1xxxxxxx1001xxxxxxxxxx
30524                                                     fcmeq.  */
30525                                                  return 555;
30526                                                }
30527                                            }
30528                                          else
30529                                            {
30530                                              if (((word >> 13) & 0x1) == 0)
30531                                                {
30532                                                  /* 33222222222211111111110000000000
30533                                                     10987654321098765432109876543210
30534                                                     x1011110xx1xxxxxxx0101xxxxxxxxxx
30535                                                     srshl.  */
30536                                                  return 564;
30537                                                }
30538                                              else
30539                                                {
30540                                                  if (((word >> 15) & 0x1) == 0)
30541                                                    {
30542                                                      /* 33222222222211111111110000000000
30543                                                         10987654321098765432109876543210
30544                                                         x1011110xx1xxxxx0x1101xxxxxxxxxx
30545                                                         cmgt.  */
30546                                                      return 561;
30547                                                    }
30548                                                  else
30549                                                    {
30550                                                      /* 33222222222211111111110000000000
30551                                                         10987654321098765432109876543210
30552                                                         x1011110xx1xxxxx1x1101xxxxxxxxxx
30553                                                         sqdmulh.  */
30554                                                      return 552;
30555                                                    }
30556                                                }
30557                                            }
30558                                        }
30559                                    }
30560                                  else
30561                                    {
30562                                      if (((word >> 12) & 0x1) == 0)
30563                                        {
30564                                          if (((word >> 13) & 0x1) == 0)
30565                                            {
30566                                              if (((word >> 14) & 0x1) == 0)
30567                                                {
30568                                                  /* 33222222222211111111110000000000
30569                                                     10987654321098765432109876543210
30570                                                     xx111110xx1xxxxxx00001xxxxxxxxxx
30571                                                     sub.  */
30572                                                  return 586;
30573                                                }
30574                                              else
30575                                                {
30576                                                  /* 33222222222211111111110000000000
30577                                                     10987654321098765432109876543210
30578                                                     xx111110xx1xxxxxx10001xxxxxxxxxx
30579                                                     ushl.  */
30580                                                  return 584;
30581                                                }
30582                                            }
30583                                          else
30584                                            {
30585                                              if (((word >> 23) & 0x1) == 0)
30586                                                {
30587                                                  /* 33222222222211111111110000000000
30588                                                     10987654321098765432109876543210
30589                                                     xx1111100x1xxxxxxx1001xxxxxxxxxx
30590                                                     fcmge.  */
30591                                                  return 572;
30592                                                }
30593                                              else
30594                                                {
30595                                                  /* 33222222222211111111110000000000
30596                                                     10987654321098765432109876543210
30597                                                     xx1111101x1xxxxxxx1001xxxxxxxxxx
30598                                                     fcmgt.  */
30599                                                  return 578;
30600                                                }
30601                                            }
30602                                        }
30603                                      else
30604                                        {
30605                                          if (((word >> 13) & 0x1) == 0)
30606                                            {
30607                                              if (((word >> 15) & 0x1) == 0)
30608                                                {
30609                                                  /* 33222222222211111111110000000000
30610                                                     10987654321098765432109876543210
30611                                                     xx111110xx1xxxxx0x0101xxxxxxxxxx
30612                                                     urshl.  */
30613                                                  return 585;
30614                                                }
30615                                              else
30616                                                {
30617                                                  /* 33222222222211111111110000000000
30618                                                     10987654321098765432109876543210
30619                                                     xx111110xx1xxxxx1x0101xxxxxxxxxx
30620                                                     fabd.  */
30621                                                  return 576;
30622                                                }
30623                                            }
30624                                          else
30625                                            {
30626                                              if (((word >> 15) & 0x1) == 0)
30627                                                {
30628                                                  /* 33222222222211111111110000000000
30629                                                     10987654321098765432109876543210
30630                                                     xx111110xx1xxxxx0x1101xxxxxxxxxx
30631                                                     cmhi.  */
30632                                                  return 582;
30633                                                }
30634                                              else
30635                                                {
30636                                                  /* 33222222222211111111110000000000
30637                                                     10987654321098765432109876543210
30638                                                     xx111110xx1xxxxx1x1101xxxxxxxxxx
30639                                                     sqrdmulh.  */
30640                                                  return 571;
30641                                                }
30642                                            }
30643                                        }
30644                                    }
30645                                }
30646                              else
30647                                {
30648                                  if (((word >> 29) & 0x1) == 0)
30649                                    {
30650                                      if (((word >> 30) & 0x1) == 0)
30651                                        {
30652                                          /* 33222222222211111111110000000000
30653                                             10987654321098765432109876543210
30654                                             x0011110xx1xxxxxxxxx11xxxxxxxxxx
30655                                             fcsel.  */
30656                                          return 868;
30657                                        }
30658                                      else
30659                                        {
30660                                          if (((word >> 12) & 0x1) == 0)
30661                                            {
30662                                              if (((word >> 13) & 0x1) == 0)
30663                                                {
30664                                                  if (((word >> 14) & 0x1) == 0)
30665                                                    {
30666                                                      if (((word >> 15) & 0x1) == 0)
30667                                                        {
30668                                                          /* 33222222222211111111110000000000
30669                                                             10987654321098765432109876543210
30670                                                             x1011110xx1xxxxx000011xxxxxxxxxx
30671                                                             sqadd.  */
30672                                                          return 548;
30673                                                        }
30674                                                      else
30675                                                        {
30676                                                          /* 33222222222211111111110000000000
30677                                                             10987654321098765432109876543210
30678                                                             x1011110xx1xxxxx100011xxxxxxxxxx
30679                                                             cmtst.  */
30680                                                          return 566;
30681                                                        }
30682                                                    }
30683                                                  else
30684                                                    {
30685                                                      /* 33222222222211111111110000000000
30686                                                         10987654321098765432109876543210
30687                                                         x1011110xx1xxxxxx10011xxxxxxxxxx
30688                                                         sqshl.  */
30689                                                      return 550;
30690                                                    }
30691                                                }
30692                                              else
30693                                                {
30694                                                  /* 33222222222211111111110000000000
30695                                                     10987654321098765432109876543210
30696                                                     x1011110xx1xxxxxxx1011xxxxxxxxxx
30697                                                     sqsub.  */
30698                                                  return 549;
30699                                                }
30700                                            }
30701                                          else
30702                                            {
30703                                              if (((word >> 13) & 0x1) == 0)
30704                                                {
30705                                                  if (((word >> 15) & 0x1) == 0)
30706                                                    {
30707                                                      /* 33222222222211111111110000000000
30708                                                         10987654321098765432109876543210
30709                                                         x1011110xx1xxxxx0x0111xxxxxxxxxx
30710                                                         sqrshl.  */
30711                                                      return 551;
30712                                                    }
30713                                                  else
30714                                                    {
30715                                                      /* 33222222222211111111110000000000
30716                                                         10987654321098765432109876543210
30717                                                         x1011110xx1xxxxx1x0111xxxxxxxxxx
30718                                                         fmulx.  */
30719                                                      return 553;
30720                                                    }
30721                                                }
30722                                              else
30723                                                {
30724                                                  if (((word >> 14) & 0x1) == 0)
30725                                                    {
30726                                                      /* 33222222222211111111110000000000
30727                                                         10987654321098765432109876543210
30728                                                         x1011110xx1xxxxxx01111xxxxxxxxxx
30729                                                         cmge.  */
30730                                                      return 562;
30731                                                    }
30732                                                  else
30733                                                    {
30734                                                      if (((word >> 23) & 0x1) == 0)
30735                                                        {
30736                                                          /* 33222222222211111111110000000000
30737                                                             10987654321098765432109876543210
30738                                                             x10111100x1xxxxxx11111xxxxxxxxxx
30739                                                             frecps.  */
30740                                                          return 557;
30741                                                        }
30742                                                      else
30743                                                        {
30744                                                          /* 33222222222211111111110000000000
30745                                                             10987654321098765432109876543210
30746                                                             x10111101x1xxxxxx11111xxxxxxxxxx
30747                                                             frsqrts.  */
30748                                                          return 559;
30749                                                        }
30750                                                    }
30751                                                }
30752                                            }
30753                                        }
30754                                    }
30755                                  else
30756                                    {
30757                                      if (((word >> 12) & 0x1) == 0)
30758                                        {
30759                                          if (((word >> 13) & 0x1) == 0)
30760                                            {
30761                                              if (((word >> 14) & 0x1) == 0)
30762                                                {
30763                                                  if (((word >> 15) & 0x1) == 0)
30764                                                    {
30765                                                      /* 33222222222211111111110000000000
30766                                                         10987654321098765432109876543210
30767                                                         xx111110xx1xxxxx000011xxxxxxxxxx
30768                                                         uqadd.  */
30769                                                      return 567;
30770                                                    }
30771                                                  else
30772                                                    {
30773                                                      /* 33222222222211111111110000000000
30774                                                         10987654321098765432109876543210
30775                                                         xx111110xx1xxxxx100011xxxxxxxxxx
30776                                                         cmeq.  */
30777                                                      return 587;
30778                                                    }
30779                                                }
30780                                              else
30781                                                {
30782                                                  /* 33222222222211111111110000000000
30783                                                     10987654321098765432109876543210
30784                                                     xx111110xx1xxxxxx10011xxxxxxxxxx
30785                                                     uqshl.  */
30786                                                  return 569;
30787                                                }
30788                                            }
30789                                          else
30790                                            {
30791                                              if (((word >> 14) & 0x1) == 0)
30792                                                {
30793                                                  /* 33222222222211111111110000000000
30794                                                     10987654321098765432109876543210
30795                                                     xx111110xx1xxxxxx01011xxxxxxxxxx
30796                                                     uqsub.  */
30797                                                  return 568;
30798                                                }
30799                                              else
30800                                                {
30801                                                  if (((word >> 23) & 0x1) == 0)
30802                                                    {
30803                                                      /* 33222222222211111111110000000000
30804                                                         10987654321098765432109876543210
30805                                                         xx1111100x1xxxxxx11011xxxxxxxxxx
30806                                                         facge.  */
30807                                                      return 574;
30808                                                    }
30809                                                  else
30810                                                    {
30811                                                      /* 33222222222211111111110000000000
30812                                                         10987654321098765432109876543210
30813                                                         xx1111101x1xxxxxx11011xxxxxxxxxx
30814                                                         facgt.  */
30815                                                      return 580;
30816                                                    }
30817                                                }
30818                                            }
30819                                        }
30820                                      else
30821                                        {
30822                                          if (((word >> 13) & 0x1) == 0)
30823                                            {
30824                                              /* 33222222222211111111110000000000
30825                                                 10987654321098765432109876543210
30826                                                 xx111110xx1xxxxxxx0111xxxxxxxxxx
30827                                                 uqrshl.  */
30828                                              return 570;
30829                                            }
30830                                          else
30831                                            {
30832                                              /* 33222222222211111111110000000000
30833                                                 10987654321098765432109876543210
30834                                                 xx111110xx1xxxxxxx1111xxxxxxxxxx
30835                                                 cmhs.  */
30836                                              return 583;
30837                                            }
30838                                        }
30839                                    }
30840                                }
30841                            }
30842                        }
30843                    }
30844                }
30845              else
30846                {
30847                  if (((word >> 15) & 0x1) == 0)
30848                    {
30849                      if (((word >> 28) & 0x1) == 0)
30850                        {
30851                          if (((word >> 10) & 0x1) == 0)
30852                            {
30853                              if (((word >> 12) & 0x1) == 0)
30854                                {
30855                                  if (((word >> 13) & 0x1) == 0)
30856                                    {
30857                                      if (((word >> 14) & 0x1) == 0)
30858                                        {
30859                                          if (((word >> 29) & 0x1) == 0)
30860                                            {
30861                                              if (((word >> 30) & 0x1) == 0)
30862                                                {
30863                                                  /* 33222222222211111111110000000000
30864                                                     10987654321098765432109876543210
30865                                                     x0001111xxxxxxxx0000x0xxxxxxxxxx
30866                                                     fmlal.  */
30867                                                  return 3002;
30868                                                }
30869                                              else
30870                                                {
30871                                                  /* 33222222222211111111110000000000
30872                                                     10987654321098765432109876543210
30873                                                     x1001111xxxxxxxx0000x0xxxxxxxxxx
30874                                                     fmlal.  */
30875                                                  return 3006;
30876                                                }
30877                                            }
30878                                          else
30879                                            {
30880                                              /* 33222222222211111111110000000000
30881                                                 10987654321098765432109876543210
30882                                                 xx101111xxxxxxxx0000x0xxxxxxxxxx
30883                                                 mla.  */
30884                                              return 119;
30885                                            }
30886                                        }
30887                                      else
30888                                        {
30889                                          if (((word >> 29) & 0x1) == 0)
30890                                            {
30891                                              if (((word >> 30) & 0x1) == 0)
30892                                                {
30893                                                  /* 33222222222211111111110000000000
30894                                                     10987654321098765432109876543210
30895                                                     x0001111xxxxxxxx0100x0xxxxxxxxxx
30896                                                     fmlsl.  */
30897                                                  return 3003;
30898                                                }
30899                                              else
30900                                                {
30901                                                  /* 33222222222211111111110000000000
30902                                                     10987654321098765432109876543210
30903                                                     x1001111xxxxxxxx0100x0xxxxxxxxxx
30904                                                     fmlsl.  */
30905                                                  return 3007;
30906                                                }
30907                                            }
30908                                          else
30909                                            {
30910                                              /* 33222222222211111111110000000000
30911                                                 10987654321098765432109876543210
30912                                                 xx101111xxxxxxxx0100x0xxxxxxxxxx
30913                                                 mls.  */
30914                                              return 122;
30915                                            }
30916                                        }
30917                                    }
30918                                  else
30919                                    {
30920                                      if (((word >> 14) & 0x1) == 0)
30921                                        {
30922                                          if (((word >> 29) & 0x1) == 0)
30923                                            {
30924                                              if (((word >> 30) & 0x1) == 0)
30925                                                {
30926                                                  /* 33222222222211111111110000000000
30927                                                     10987654321098765432109876543210
30928                                                     x0001111xxxxxxxx0010x0xxxxxxxxxx
30929                                                     smlal.  */
30930                                                  return 98;
30931                                                }
30932                                              else
30933                                                {
30934                                                  /* 33222222222211111111110000000000
30935                                                     10987654321098765432109876543210
30936                                                     x1001111xxxxxxxx0010x0xxxxxxxxxx
30937                                                     smlal2.  */
30938                                                  return 99;
30939                                                }
30940                                            }
30941                                          else
30942                                            {
30943                                              if (((word >> 30) & 0x1) == 0)
30944                                                {
30945                                                  /* 33222222222211111111110000000000
30946                                                     10987654321098765432109876543210
30947                                                     x0101111xxxxxxxx0010x0xxxxxxxxxx
30948                                                     umlal.  */
30949                                                  return 120;
30950                                                }
30951                                              else
30952                                                {
30953                                                  /* 33222222222211111111110000000000
30954                                                     10987654321098765432109876543210
30955                                                     x1101111xxxxxxxx0010x0xxxxxxxxxx
30956                                                     umlal2.  */
30957                                                  return 121;
30958                                                }
30959                                            }
30960                                        }
30961                                      else
30962                                        {
30963                                          if (((word >> 29) & 0x1) == 0)
30964                                            {
30965                                              if (((word >> 30) & 0x1) == 0)
30966                                                {
30967                                                  /* 33222222222211111111110000000000
30968                                                     10987654321098765432109876543210
30969                                                     x0001111xxxxxxxx0110x0xxxxxxxxxx
30970                                                     smlsl.  */
30971                                                  return 102;
30972                                                }
30973                                              else
30974                                                {
30975                                                  /* 33222222222211111111110000000000
30976                                                     10987654321098765432109876543210
30977                                                     x1001111xxxxxxxx0110x0xxxxxxxxxx
30978                                                     smlsl2.  */
30979                                                  return 103;
30980                                                }
30981                                            }
30982                                          else
30983                                            {
30984                                              if (((word >> 30) & 0x1) == 0)
30985                                                {
30986                                                  /* 33222222222211111111110000000000
30987                                                     10987654321098765432109876543210
30988                                                     x0101111xxxxxxxx0110x0xxxxxxxxxx
30989                                                     umlsl.  */
30990                                                  return 123;
30991                                                }
30992                                              else
30993                                                {
30994                                                  /* 33222222222211111111110000000000
30995                                                     10987654321098765432109876543210
30996                                                     x1101111xxxxxxxx0110x0xxxxxxxxxx
30997                                                     umlsl2.  */
30998                                                  return 124;
30999                                                }
31000                                            }
31001                                        }
31002                                    }
31003                                }
31004                              else
31005                                {
31006                                  if (((word >> 29) & 0x1) == 0)
31007                                    {
31008                                      if (((word >> 13) & 0x1) == 0)
31009                                        {
31010                                          if (((word >> 14) & 0x1) == 0)
31011                                            {
31012                                              if (((word >> 23) & 0x1) == 0)
31013                                                {
31014                                                  /* 33222222222211111111110000000000
31015                                                     10987654321098765432109876543210
31016                                                     xx0011110xxxxxxx0001x0xxxxxxxxxx
31017                                                     fmla.  */
31018                                                  return 114;
31019                                                }
31020                                              else
31021                                                {
31022                                                  /* 33222222222211111111110000000000
31023                                                     10987654321098765432109876543210
31024                                                     xx0011111xxxxxxx0001x0xxxxxxxxxx
31025                                                     fmla.  */
31026                                                  return 113;
31027                                                }
31028                                            }
31029                                          else
31030                                            {
31031                                              if (((word >> 23) & 0x1) == 0)
31032                                                {
31033                                                  /* 33222222222211111111110000000000
31034                                                     10987654321098765432109876543210
31035                                                     xx0011110xxxxxxx0101x0xxxxxxxxxx
31036                                                     fmls.  */
31037                                                  return 116;
31038                                                }
31039                                              else
31040                                                {
31041                                                  /* 33222222222211111111110000000000
31042                                                     10987654321098765432109876543210
31043                                                     xx0011111xxxxxxx0101x0xxxxxxxxxx
31044                                                     fmls.  */
31045                                                  return 115;
31046                                                }
31047                                            }
31048                                        }
31049                                      else
31050                                        {
31051                                          if (((word >> 14) & 0x1) == 0)
31052                                            {
31053                                              if (((word >> 30) & 0x1) == 0)
31054                                                {
31055                                                  /* 33222222222211111111110000000000
31056                                                     10987654321098765432109876543210
31057                                                     x0001111xxxxxxxx0011x0xxxxxxxxxx
31058                                                     sqdmlal.  */
31059                                                  return 100;
31060                                                }
31061                                              else
31062                                                {
31063                                                  /* 33222222222211111111110000000000
31064                                                     10987654321098765432109876543210
31065                                                     x1001111xxxxxxxx0011x0xxxxxxxxxx
31066                                                     sqdmlal2.  */
31067                                                  return 101;
31068                                                }
31069                                            }
31070                                          else
31071                                            {
31072                                              if (((word >> 30) & 0x1) == 0)
31073                                                {
31074                                                  /* 33222222222211111111110000000000
31075                                                     10987654321098765432109876543210
31076                                                     x0001111xxxxxxxx0111x0xxxxxxxxxx
31077                                                     sqdmlsl.  */
31078                                                  return 104;
31079                                                }
31080                                              else
31081                                                {
31082                                                  /* 33222222222211111111110000000000
31083                                                     10987654321098765432109876543210
31084                                                     x1001111xxxxxxxx0111x0xxxxxxxxxx
31085                                                     sqdmlsl2.  */
31086                                                  return 105;
31087                                                }
31088                                            }
31089                                        }
31090                                    }
31091                                  else
31092                                    {
31093                                      /* 33222222222211111111110000000000
31094                                         10987654321098765432109876543210
31095                                         xx101111xxxxxxxx0xx1x0xxxxxxxxxx
31096                                         fcmla.  */
31097                                      return 131;
31098                                    }
31099                                }
31100                            }
31101                          else
31102                            {
31103                              if (((word >> 12) & 0x1) == 0)
31104                                {
31105                                  if (((word >> 29) & 0x1) == 0)
31106                                    {
31107                                      /* 33222222222211111111110000000000
31108                                         10987654321098765432109876543210
31109                                         xx001111xxxxxxxx0xx0x1xxxxxxxxxx
31110                                         movi.  */
31111                                      return 133;
31112                                    }
31113                                  else
31114                                    {
31115                                      /* 33222222222211111111110000000000
31116                                         10987654321098765432109876543210
31117                                         xx101111xxxxxxxx0xx0x1xxxxxxxxxx
31118                                         mvni.  */
31119                                      return 141;
31120                                    }
31121                                }
31122                              else
31123                                {
31124                                  if (((word >> 29) & 0x1) == 0)
31125                                    {
31126                                      /* 33222222222211111111110000000000
31127                                         10987654321098765432109876543210
31128                                         xx001111xxxxxxxx0xx1x1xxxxxxxxxx
31129                                         orr.  */
31130                                      return 134;
31131                                    }
31132                                  else
31133                                    {
31134                                      /* 33222222222211111111110000000000
31135                                         10987654321098765432109876543210
31136                                         xx101111xxxxxxxx0xx1x1xxxxxxxxxx
31137                                         bic.  */
31138                                      return 142;
31139                                    }
31140                                }
31141                            }
31142                        }
31143                      else
31144                        {
31145                          if (((word >> 29) & 0x1) == 0)
31146                            {
31147                              if (((word >> 30) & 0x1) == 0)
31148                                {
31149                                  if (((word >> 21) & 0x1) == 0)
31150                                    {
31151                                      /* 33222222222211111111110000000000
31152                                         10987654321098765432109876543210
31153                                         x0011111xx0xxxxx0xxxxxxxxxxxxxxx
31154                                         fmadd.  */
31155                                      return 858;
31156                                    }
31157                                  else
31158                                    {
31159                                      /* 33222222222211111111110000000000
31160                                         10987654321098765432109876543210
31161                                         x0011111xx1xxxxx0xxxxxxxxxxxxxxx
31162                                         fnmadd.  */
31163                                      return 862;
31164                                    }
31165                                }
31166                              else
31167                                {
31168                                  if (((word >> 10) & 0x1) == 0)
31169                                    {
31170                                      if (((word >> 13) & 0x1) == 0)
31171                                        {
31172                                          if (((word >> 14) & 0x1) == 0)
31173                                            {
31174                                              if (((word >> 23) & 0x1) == 0)
31175                                                {
31176                                                  /* 33222222222211111111110000000000
31177                                                     10987654321098765432109876543210
31178                                                     x10111110xxxxxxx000xx0xxxxxxxxxx
31179                                                     fmla.  */
31180                                                  return 431;
31181                                                }
31182                                              else
31183                                                {
31184                                                  /* 33222222222211111111110000000000
31185                                                     10987654321098765432109876543210
31186                                                     x10111111xxxxxxx000xx0xxxxxxxxxx
31187                                                     fmla.  */
31188                                                  return 430;
31189                                                }
31190                                            }
31191                                          else
31192                                            {
31193                                              if (((word >> 23) & 0x1) == 0)
31194                                                {
31195                                                  /* 33222222222211111111110000000000
31196                                                     10987654321098765432109876543210
31197                                                     x10111110xxxxxxx010xx0xxxxxxxxxx
31198                                                     fmls.  */
31199                                                  return 433;
31200                                                }
31201                                              else
31202                                                {
31203                                                  /* 33222222222211111111110000000000
31204                                                     10987654321098765432109876543210
31205                                                     x10111111xxxxxxx010xx0xxxxxxxxxx
31206                                                     fmls.  */
31207                                                  return 432;
31208                                                }
31209                                            }
31210                                        }
31211                                      else
31212                                        {
31213                                          if (((word >> 14) & 0x1) == 0)
31214                                            {
31215                                              /* 33222222222211111111110000000000
31216                                                 10987654321098765432109876543210
31217                                                 x1011111xxxxxxxx001xx0xxxxxxxxxx
31218                                                 sqdmlal.  */
31219                                              return 425;
31220                                            }
31221                                          else
31222                                            {
31223                                              /* 33222222222211111111110000000000
31224                                                 10987654321098765432109876543210
31225                                                 x1011111xxxxxxxx011xx0xxxxxxxxxx
31226                                                 sqdmlsl.  */
31227                                              return 426;
31228                                            }
31229                                        }
31230                                    }
31231                                  else
31232                                    {
31233                                      if (((word >> 12) & 0x1) == 0)
31234                                        {
31235                                          if (((word >> 13) & 0x1) == 0)
31236                                            {
31237                                              /* 33222222222211111111110000000000
31238                                                 10987654321098765432109876543210
31239                                                 x1011111xxxxxxxx0x00x1xxxxxxxxxx
31240                                                 sshr.  */
31241                                              return 590;
31242                                            }
31243                                          else
31244                                            {
31245                                              /* 33222222222211111111110000000000
31246                                                 10987654321098765432109876543210
31247                                                 x1011111xxxxxxxx0x10x1xxxxxxxxxx
31248                                                 srshr.  */
31249                                              return 592;
31250                                            }
31251                                        }
31252                                      else
31253                                        {
31254                                          if (((word >> 13) & 0x1) == 0)
31255                                            {
31256                                              if (((word >> 14) & 0x1) == 0)
31257                                                {
31258                                                  /* 33222222222211111111110000000000
31259                                                     10987654321098765432109876543210
31260                                                     x1011111xxxxxxxx0001x1xxxxxxxxxx
31261                                                     ssra.  */
31262                                                  return 591;
31263                                                }
31264                                              else
31265                                                {
31266                                                  /* 33222222222211111111110000000000
31267                                                     10987654321098765432109876543210
31268                                                     x1011111xxxxxxxx0101x1xxxxxxxxxx
31269                                                     shl.  */
31270                                                  return 594;
31271                                                }
31272                                            }
31273                                          else
31274                                            {
31275                                              if (((word >> 14) & 0x1) == 0)
31276                                                {
31277                                                  /* 33222222222211111111110000000000
31278                                                     10987654321098765432109876543210
31279                                                     x1011111xxxxxxxx0011x1xxxxxxxxxx
31280                                                     srsra.  */
31281                                                  return 593;
31282                                                }
31283                                              else
31284                                                {
31285                                                  /* 33222222222211111111110000000000
31286                                                     10987654321098765432109876543210
31287                                                     x1011111xxxxxxxx0111x1xxxxxxxxxx
31288                                                     sqshl.  */
31289                                                  return 595;
31290                                                }
31291                                            }
31292                                        }
31293                                    }
31294                                }
31295                            }
31296                          else
31297                            {
31298                              if (((word >> 12) & 0x1) == 0)
31299                                {
31300                                  if (((word >> 13) & 0x1) == 0)
31301                                    {
31302                                      if (((word >> 14) & 0x1) == 0)
31303                                        {
31304                                          /* 33222222222211111111110000000000
31305                                             10987654321098765432109876543210
31306                                             xx111111xxxxxxxx0000xxxxxxxxxxxx
31307                                             ushr.  */
31308                                          return 602;
31309                                        }
31310                                      else
31311                                        {
31312                                          /* 33222222222211111111110000000000
31313                                             10987654321098765432109876543210
31314                                             xx111111xxxxxxxx0100xxxxxxxxxxxx
31315                                             sri.  */
31316                                          return 606;
31317                                        }
31318                                    }
31319                                  else
31320                                    {
31321                                      if (((word >> 14) & 0x1) == 0)
31322                                        {
31323                                          /* 33222222222211111111110000000000
31324                                             10987654321098765432109876543210
31325                                             xx111111xxxxxxxx0010xxxxxxxxxxxx
31326                                             urshr.  */
31327                                          return 604;
31328                                        }
31329                                      else
31330                                        {
31331                                          /* 33222222222211111111110000000000
31332                                             10987654321098765432109876543210
31333                                             xx111111xxxxxxxx0110xxxxxxxxxxxx
31334                                             sqshlu.  */
31335                                          return 608;
31336                                        }
31337                                    }
31338                                }
31339                              else
31340                                {
31341                                  if (((word >> 13) & 0x1) == 0)
31342                                    {
31343                                      if (((word >> 14) & 0x1) == 0)
31344                                        {
31345                                          /* 33222222222211111111110000000000
31346                                             10987654321098765432109876543210
31347                                             xx111111xxxxxxxx0001xxxxxxxxxxxx
31348                                             usra.  */
31349                                          return 603;
31350                                        }
31351                                      else
31352                                        {
31353                                          /* 33222222222211111111110000000000
31354                                             10987654321098765432109876543210
31355                                             xx111111xxxxxxxx0101xxxxxxxxxxxx
31356                                             sli.  */
31357                                          return 607;
31358                                        }
31359                                    }
31360                                  else
31361                                    {
31362                                      if (((word >> 14) & 0x1) == 0)
31363                                        {
31364                                          /* 33222222222211111111110000000000
31365                                             10987654321098765432109876543210
31366                                             xx111111xxxxxxxx0011xxxxxxxxxxxx
31367                                             ursra.  */
31368                                          return 605;
31369                                        }
31370                                      else
31371                                        {
31372                                          /* 33222222222211111111110000000000
31373                                             10987654321098765432109876543210
31374                                             xx111111xxxxxxxx0111xxxxxxxxxxxx
31375                                             uqshl.  */
31376                                          return 609;
31377                                        }
31378                                    }
31379                                }
31380                            }
31381                        }
31382                    }
31383                  else
31384                    {
31385                      if (((word >> 28) & 0x1) == 0)
31386                        {
31387                          if (((word >> 10) & 0x1) == 0)
31388                            {
31389                              if (((word >> 12) & 0x1) == 0)
31390                                {
31391                                  if (((word >> 13) & 0x1) == 0)
31392                                    {
31393                                      if (((word >> 14) & 0x1) == 0)
31394                                        {
31395                                          if (((word >> 29) & 0x1) == 0)
31396                                            {
31397                                              /* 33222222222211111111110000000000
31398                                                 10987654321098765432109876543210
31399                                                 xx001111xxxxxxxx1000x0xxxxxxxxxx
31400                                                 mul.  */
31401                                              return 106;
31402                                            }
31403                                          else
31404                                            {
31405                                              if (((word >> 30) & 0x1) == 0)
31406                                                {
31407                                                  /* 33222222222211111111110000000000
31408                                                     10987654321098765432109876543210
31409                                                     x0101111xxxxxxxx1000x0xxxxxxxxxx
31410                                                     fmlal2.  */
31411                                                  return 3004;
31412                                                }
31413                                              else
31414                                                {
31415                                                  /* 33222222222211111111110000000000
31416                                                     10987654321098765432109876543210
31417                                                     x1101111xxxxxxxx1000x0xxxxxxxxxx
31418                                                     fmlal2.  */
31419                                                  return 3008;
31420                                                }
31421                                            }
31422                                        }
31423                                      else
31424                                        {
31425                                          if (((word >> 29) & 0x1) == 0)
31426                                            {
31427                                              /* 33222222222211111111110000000000
31428                                                 10987654321098765432109876543210
31429                                                 xx001111xxxxxxxx1100x0xxxxxxxxxx
31430                                                 sqdmulh.  */
31431                                              return 111;
31432                                            }
31433                                          else
31434                                            {
31435                                              if (((word >> 30) & 0x1) == 0)
31436                                                {
31437                                                  /* 33222222222211111111110000000000
31438                                                     10987654321098765432109876543210
31439                                                     x0101111xxxxxxxx1100x0xxxxxxxxxx
31440                                                     fmlsl2.  */
31441                                                  return 3005;
31442                                                }
31443                                              else
31444                                                {
31445                                                  /* 33222222222211111111110000000000
31446                                                     10987654321098765432109876543210
31447                                                     x1101111xxxxxxxx1100x0xxxxxxxxxx
31448                                                     fmlsl2.  */
31449                                                  return 3009;
31450                                                }
31451                                            }
31452                                        }
31453                                    }
31454                                  else
31455                                    {
31456                                      if (((word >> 14) & 0x1) == 0)
31457                                        {
31458                                          if (((word >> 29) & 0x1) == 0)
31459                                            {
31460                                              if (((word >> 30) & 0x1) == 0)
31461                                                {
31462                                                  /* 33222222222211111111110000000000
31463                                                     10987654321098765432109876543210
31464                                                     x0001111xxxxxxxx1010x0xxxxxxxxxx
31465                                                     smull.  */
31466                                                  return 107;
31467                                                }
31468                                              else
31469                                                {
31470                                                  /* 33222222222211111111110000000000
31471                                                     10987654321098765432109876543210
31472                                                     x1001111xxxxxxxx1010x0xxxxxxxxxx
31473                                                     smull2.  */
31474                                                  return 108;
31475                                                }
31476                                            }
31477                                          else
31478                                            {
31479                                              if (((word >> 30) & 0x1) == 0)
31480                                                {
31481                                                  /* 33222222222211111111110000000000
31482                                                     10987654321098765432109876543210
31483                                                     x0101111xxxxxxxx1010x0xxxxxxxxxx
31484                                                     umull.  */
31485                                                  return 125;
31486                                                }
31487                                              else
31488                                                {
31489                                                  /* 33222222222211111111110000000000
31490                                                     10987654321098765432109876543210
31491                                                     x1101111xxxxxxxx1010x0xxxxxxxxxx
31492                                                     umull2.  */
31493                                                  return 126;
31494                                                }
31495                                            }
31496                                        }
31497                                      else
31498                                        {
31499                                          if (((word >> 29) & 0x1) == 0)
31500                                            {
31501                                              /* 33222222222211111111110000000000
31502                                                 10987654321098765432109876543210
31503                                                 xx001111xxxxxxxx1110x0xxxxxxxxxx
31504                                                 sdot.  */
31505                                              return 2976;
31506                                            }
31507                                          else
31508                                            {
31509                                              /* 33222222222211111111110000000000
31510                                                 10987654321098765432109876543210
31511                                                 xx101111xxxxxxxx1110x0xxxxxxxxxx
31512                                                 udot.  */
31513                                              return 2975;
31514                                            }
31515                                        }
31516                                    }
31517                                }
31518                              else
31519                                {
31520                                  if (((word >> 13) & 0x1) == 0)
31521                                    {
31522                                      if (((word >> 14) & 0x1) == 0)
31523                                        {
31524                                          if (((word >> 23) & 0x1) == 0)
31525                                            {
31526                                              if (((word >> 29) & 0x1) == 0)
31527                                                {
31528                                                  /* 33222222222211111111110000000000
31529                                                     10987654321098765432109876543210
31530                                                     xx0011110xxxxxxx1001x0xxxxxxxxxx
31531                                                     fmul.  */
31532                                                  return 118;
31533                                                }
31534                                              else
31535                                                {
31536                                                  /* 33222222222211111111110000000000
31537                                                     10987654321098765432109876543210
31538                                                     xx1011110xxxxxxx1001x0xxxxxxxxxx
31539                                                     fmulx.  */
31540                                                  return 128;
31541                                                }
31542                                            }
31543                                          else
31544                                            {
31545                                              if (((word >> 29) & 0x1) == 0)
31546                                                {
31547                                                  /* 33222222222211111111110000000000
31548                                                     10987654321098765432109876543210
31549                                                     xx0011111xxxxxxx1001x0xxxxxxxxxx
31550                                                     fmul.  */
31551                                                  return 117;
31552                                                }
31553                                              else
31554                                                {
31555                                                  /* 33222222222211111111110000000000
31556                                                     10987654321098765432109876543210
31557                                                     xx1011111xxxxxxx1001x0xxxxxxxxxx
31558                                                     fmulx.  */
31559                                                  return 127;
31560                                                }
31561                                            }
31562                                        }
31563                                      else
31564                                        {
31565                                          if (((word >> 29) & 0x1) == 0)
31566                                            {
31567                                              /* 33222222222211111111110000000000
31568                                                 10987654321098765432109876543210
31569                                                 xx001111xxxxxxxx1101x0xxxxxxxxxx
31570                                                 sqrdmulh.  */
31571                                              return 112;
31572                                            }
31573                                          else
31574                                            {
31575                                              /* 33222222222211111111110000000000
31576                                                 10987654321098765432109876543210
31577                                                 xx101111xxxxxxxx1101x0xxxxxxxxxx
31578                                                 sqrdmlah.  */
31579                                              return 129;
31580                                            }
31581                                        }
31582                                    }
31583                                  else
31584                                    {
31585                                      if (((word >> 14) & 0x1) == 0)
31586                                        {
31587                                          if (((word >> 30) & 0x1) == 0)
31588                                            {
31589                                              /* 33222222222211111111110000000000
31590                                                 10987654321098765432109876543210
31591                                                 x0x01111xxxxxxxx1011x0xxxxxxxxxx
31592                                                 sqdmull.  */
31593                                              return 109;
31594                                            }
31595                                          else
31596                                            {
31597                                              /* 33222222222211111111110000000000
31598                                                 10987654321098765432109876543210
31599                                                 x1x01111xxxxxxxx1011x0xxxxxxxxxx
31600                                                 sqdmull2.  */
31601                                              return 110;
31602                                            }
31603                                        }
31604                                      else
31605                                        {
31606                                          if (((word >> 29) & 0x1) == 0)
31607                                            {
31608                                              if (((word >> 22) & 0x1) == 0)
31609                                                {
31610                                                  if (((word >> 23) & 0x1) == 0)
31611                                                    {
31612                                                      /* 33222222222211111111110000000000
31613                                                         10987654321098765432109876543210
31614                                                         xx00111100xxxxxx1111x0xxxxxxxxxx
31615                                                         sudot.  */
31616                                                      return 3053;
31617                                                    }
31618                                                  else
31619                                                    {
31620                                                      /* 33222222222211111111110000000000
31621                                                         10987654321098765432109876543210
31622                                                         xx00111110xxxxxx1111x0xxxxxxxxxx
31623                                                         usdot.  */
31624                                                      return 3052;
31625                                                    }
31626                                                }
31627                                              else
31628                                                {
31629                                                  if (((word >> 23) & 0x1) == 0)
31630                                                    {
31631                                                      /* 33222222222211111111110000000000
31632                                                         10987654321098765432109876543210
31633                                                         xx00111101xxxxxx1111x0xxxxxxxxxx
31634                                                         bfdot.  */
31635                                                      return 3064;
31636                                                    }
31637                                                  else
31638                                                    {
31639                                                      if (((word >> 30) & 0x1) == 0)
31640                                                        {
31641                                                          /* 33222222222211111111110000000000
31642                                                             10987654321098765432109876543210
31643                                                             x000111111xxxxxx1111x0xxxxxxxxxx
31644                                                             bfmlalb.  */
31645                                                          return 3072;
31646                                                        }
31647                                                      else
31648                                                        {
31649                                                          /* 33222222222211111111110000000000
31650                                                             10987654321098765432109876543210
31651                                                             x100111111xxxxxx1111x0xxxxxxxxxx
31652                                                             bfmlalt.  */
31653                                                          return 3071;
31654                                                        }
31655                                                    }
31656                                                }
31657                                            }
31658                                          else
31659                                            {
31660                                              /* 33222222222211111111110000000000
31661                                                 10987654321098765432109876543210
31662                                                 xx101111xxxxxxxx1111x0xxxxxxxxxx
31663                                                 sqrdmlsh.  */
31664                                              return 130;
31665                                            }
31666                                        }
31667                                    }
31668                                }
31669                            }
31670                          else
31671                            {
31672                              if (((word >> 11) & 0x1) == 0)
31673                                {
31674                                  if (((word >> 14) & 0x1) == 0)
31675                                    {
31676                                      if (((word >> 12) & 0x1) == 0)
31677                                        {
31678                                          if (((word >> 29) & 0x1) == 0)
31679                                            {
31680                                              /* 33222222222211111111110000000000
31681                                                 10987654321098765432109876543210
31682                                                 xx001111xxxxxxxx10x001xxxxxxxxxx
31683                                                 movi.  */
31684                                              return 135;
31685                                            }
31686                                          else
31687                                            {
31688                                              /* 33222222222211111111110000000000
31689                                                 10987654321098765432109876543210
31690                                                 xx101111xxxxxxxx10x001xxxxxxxxxx
31691                                                 mvni.  */
31692                                              return 143;
31693                                            }
31694                                        }
31695                                      else
31696                                        {
31697                                          if (((word >> 29) & 0x1) == 0)
31698                                            {
31699                                              /* 33222222222211111111110000000000
31700                                                 10987654321098765432109876543210
31701                                                 xx001111xxxxxxxx10x101xxxxxxxxxx
31702                                                 orr.  */
31703                                              return 136;
31704                                            }
31705                                          else
31706                                            {
31707                                              /* 33222222222211111111110000000000
31708                                                 10987654321098765432109876543210
31709                                                 xx101111xxxxxxxx10x101xxxxxxxxxx
31710                                                 bic.  */
31711                                              return 144;
31712                                            }
31713                                        }
31714                                    }
31715                                  else
31716                                    {
31717                                      if (((word >> 13) & 0x1) == 0)
31718                                        {
31719                                          if (((word >> 29) & 0x1) == 0)
31720                                            {
31721                                              /* 33222222222211111111110000000000
31722                                                 10987654321098765432109876543210
31723                                                 xx001111xxxxxxxx110x01xxxxxxxxxx
31724                                                 movi.  */
31725                                              return 137;
31726                                            }
31727                                          else
31728                                            {
31729                                              /* 33222222222211111111110000000000
31730                                                 10987654321098765432109876543210
31731                                                 xx101111xxxxxxxx110x01xxxxxxxxxx
31732                                                 mvni.  */
31733                                              return 145;
31734                                            }
31735                                        }
31736                                      else
31737                                        {
31738                                          if (((word >> 12) & 0x1) == 0)
31739                                            {
31740                                              if (((word >> 29) & 0x1) == 0)
31741                                                {
31742                                                  /* 33222222222211111111110000000000
31743                                                     10987654321098765432109876543210
31744                                                     xx001111xxxxxxxx111001xxxxxxxxxx
31745                                                     movi.  */
31746                                                  return 138;
31747                                                }
31748                                              else
31749                                                {
31750                                                  /* 33222222222211111111110000000000
31751                                                     10987654321098765432109876543210
31752                                                     xx101111xxxxxxxx111001xxxxxxxxxx
31753                                                     movi.  */
31754                                                  return 146;
31755                                                }
31756                                            }
31757                                          else
31758                                            {
31759                                              if (((word >> 29) & 0x1) == 0)
31760                                                {
31761                                                  /* 33222222222211111111110000000000
31762                                                     10987654321098765432109876543210
31763                                                     xx001111xxxxxxxx111101xxxxxxxxxx
31764                                                     fmov.  */
31765                                                  return 139;
31766                                                }
31767                                              else
31768                                                {
31769                                                  /* 33222222222211111111110000000000
31770                                                     10987654321098765432109876543210
31771                                                     xx101111xxxxxxxx111101xxxxxxxxxx
31772                                                     fmov.  */
31773                                                  return 148;
31774                                                }
31775                                            }
31776                                        }
31777                                    }
31778                                }
31779                              else
31780                                {
31781                                  if (((word >> 12) & 0x1) == 0)
31782                                    {
31783                                      if (((word >> 29) & 0x1) == 0)
31784                                        {
31785                                          if (((word >> 30) & 0x1) == 0)
31786                                            {
31787                                              /* 33222222222211111111110000000000
31788                                                 10987654321098765432109876543210
31789                                                 x0001111xxxxxxxx1xx011xxxxxxxxxx
31790                                                 rshrn.  */
31791                                              return 382;
31792                                            }
31793                                          else
31794                                            {
31795                                              /* 33222222222211111111110000000000
31796                                                 10987654321098765432109876543210
31797                                                 x1001111xxxxxxxx1xx011xxxxxxxxxx
31798                                                 rshrn2.  */
31799                                              return 383;
31800                                            }
31801                                        }
31802                                      else
31803                                        {
31804                                          if (((word >> 30) & 0x1) == 0)
31805                                            {
31806                                              /* 33222222222211111111110000000000
31807                                                 10987654321098765432109876543210
31808                                                 x0101111xxxxxxxx1xx011xxxxxxxxxx
31809                                                 sqrshrun.  */
31810                                              return 406;
31811                                            }
31812                                          else
31813                                            {
31814                                              /* 33222222222211111111110000000000
31815                                                 10987654321098765432109876543210
31816                                                 x1101111xxxxxxxx1xx011xxxxxxxxxx
31817                                                 sqrshrun2.  */
31818                                              return 407;
31819                                            }
31820                                        }
31821                                    }
31822                                  else
31823                                    {
31824                                      if (((word >> 13) & 0x1) == 0)
31825                                        {
31826                                          if (((word >> 29) & 0x1) == 0)
31827                                            {
31828                                              if (((word >> 30) & 0x1) == 0)
31829                                                {
31830                                                  /* 33222222222211111111110000000000
31831                                                     10987654321098765432109876543210
31832                                                     x0001111xxxxxxxx1x0111xxxxxxxxxx
31833                                                     sqrshrn.  */
31834                                                  return 386;
31835                                                }
31836                                              else
31837                                                {
31838                                                  /* 33222222222211111111110000000000
31839                                                     10987654321098765432109876543210
31840                                                     x1001111xxxxxxxx1x0111xxxxxxxxxx
31841                                                     sqrshrn2.  */
31842                                                  return 387;
31843                                                }
31844                                            }
31845                                          else
31846                                            {
31847                                              if (((word >> 30) & 0x1) == 0)
31848                                                {
31849                                                  /* 33222222222211111111110000000000
31850                                                     10987654321098765432109876543210
31851                                                     x0101111xxxxxxxx1x0111xxxxxxxxxx
31852                                                     uqrshrn.  */
31853                                                  return 410;
31854                                                }
31855                                              else
31856                                                {
31857                                                  /* 33222222222211111111110000000000
31858                                                     10987654321098765432109876543210
31859                                                     x1101111xxxxxxxx1x0111xxxxxxxxxx
31860                                                     uqrshrn2.  */
31861                                                  return 411;
31862                                                }
31863                                            }
31864                                        }
31865                                      else
31866                                        {
31867                                          if (((word >> 29) & 0x1) == 0)
31868                                            {
31869                                              /* 33222222222211111111110000000000
31870                                                 10987654321098765432109876543210
31871                                                 xx001111xxxxxxxx1x1111xxxxxxxxxx
31872                                                 fmov.  */
31873                                              return 140;
31874                                            }
31875                                          else
31876                                            {
31877                                              /* 33222222222211111111110000000000
31878                                                 10987654321098765432109876543210
31879                                                 xx101111xxxxxxxx1x1111xxxxxxxxxx
31880                                                 fcvtzu.  */
31881                                              return 418;
31882                                            }
31883                                        }
31884                                    }
31885                                }
31886                            }
31887                        }
31888                      else
31889                        {
31890                          if (((word >> 29) & 0x1) == 0)
31891                            {
31892                              if (((word >> 30) & 0x1) == 0)
31893                                {
31894                                  if (((word >> 21) & 0x1) == 0)
31895                                    {
31896                                      /* 33222222222211111111110000000000
31897                                         10987654321098765432109876543210
31898                                         x0011111xx0xxxxx1xxxxxxxxxxxxxxx
31899                                         fmsub.  */
31900                                      return 860;
31901                                    }
31902                                  else
31903                                    {
31904                                      /* 33222222222211111111110000000000
31905                                         10987654321098765432109876543210
31906                                         x0011111xx1xxxxx1xxxxxxxxxxxxxxx
31907                                         fnmsub.  */
31908                                      return 864;
31909                                    }
31910                                }
31911                              else
31912                                {
31913                                  if (((word >> 10) & 0x1) == 0)
31914                                    {
31915                                      if (((word >> 12) & 0x1) == 0)
31916                                        {
31917                                          /* 33222222222211111111110000000000
31918                                             10987654321098765432109876543210
31919                                             x1011111xxxxxxxx1xx0x0xxxxxxxxxx
31920                                             sqdmulh.  */
31921                                          return 428;
31922                                        }
31923                                      else
31924                                        {
31925                                          if (((word >> 13) & 0x1) == 0)
31926                                            {
31927                                              if (((word >> 14) & 0x1) == 0)
31928                                                {
31929                                                  if (((word >> 23) & 0x1) == 0)
31930                                                    {
31931                                                      /* 33222222222211111111110000000000
31932                                                         10987654321098765432109876543210
31933                                                         x10111110xxxxxxx1001x0xxxxxxxxxx
31934                                                         fmul.  */
31935                                                      return 435;
31936                                                    }
31937                                                  else
31938                                                    {
31939                                                      /* 33222222222211111111110000000000
31940                                                         10987654321098765432109876543210
31941                                                         x10111111xxxxxxx1001x0xxxxxxxxxx
31942                                                         fmul.  */
31943                                                      return 434;
31944                                                    }
31945                                                }
31946                                              else
31947                                                {
31948                                                  /* 33222222222211111111110000000000
31949                                                     10987654321098765432109876543210
31950                                                     x1011111xxxxxxxx1101x0xxxxxxxxxx
31951                                                     sqrdmulh.  */
31952                                                  return 429;
31953                                                }
31954                                            }
31955                                          else
31956                                            {
31957                                              /* 33222222222211111111110000000000
31958                                                 10987654321098765432109876543210
31959                                                 x1011111xxxxxxxx1x11x0xxxxxxxxxx
31960                                                 sqdmull.  */
31961                                              return 427;
31962                                            }
31963                                        }
31964                                    }
31965                                  else
31966                                    {
31967                                      if (((word >> 11) & 0x1) == 0)
31968                                        {
31969                                          if (((word >> 12) & 0x1) == 0)
31970                                            {
31971                                              /* 33222222222211111111110000000000
31972                                                 10987654321098765432109876543210
31973                                                 x1011111xxxxxxxx1xx001xxxxxxxxxx
31974                                                 scvtf.  */
31975                                              return 598;
31976                                            }
31977                                          else
31978                                            {
31979                                              /* 33222222222211111111110000000000
31980                                                 10987654321098765432109876543210
31981                                                 x1011111xxxxxxxx1xx101xxxxxxxxxx
31982                                                 sqshrn.  */
31983                                              return 596;
31984                                            }
31985                                        }
31986                                      else
31987                                        {
31988                                          if (((word >> 13) & 0x1) == 0)
31989                                            {
31990                                              /* 33222222222211111111110000000000
31991                                                 10987654321098765432109876543210
31992                                                 x1011111xxxxxxxx1x0x11xxxxxxxxxx
31993                                                 sqrshrn.  */
31994                                              return 597;
31995                                            }
31996                                          else
31997                                            {
31998                                              /* 33222222222211111111110000000000
31999                                                 10987654321098765432109876543210
32000                                                 x1011111xxxxxxxx1x1x11xxxxxxxxxx
32001                                                 fcvtzs.  */
32002                                              return 600;
32003                                            }
32004                                        }
32005                                    }
32006                                }
32007                            }
32008                          else
32009                            {
32010                              if (((word >> 10) & 0x1) == 0)
32011                                {
32012                                  if (((word >> 13) & 0x1) == 0)
32013                                    {
32014                                      if (((word >> 14) & 0x1) == 0)
32015                                        {
32016                                          if (((word >> 23) & 0x1) == 0)
32017                                            {
32018                                              /* 33222222222211111111110000000000
32019                                                 10987654321098765432109876543210
32020                                                 xx1111110xxxxxxx100xx0xxxxxxxxxx
32021                                                 fmulx.  */
32022                                              return 437;
32023                                            }
32024                                          else
32025                                            {
32026                                              /* 33222222222211111111110000000000
32027                                                 10987654321098765432109876543210
32028                                                 xx1111111xxxxxxx100xx0xxxxxxxxxx
32029                                                 fmulx.  */
32030                                              return 436;
32031                                            }
32032                                        }
32033                                      else
32034                                        {
32035                                          /* 33222222222211111111110000000000
32036                                             10987654321098765432109876543210
32037                                             xx111111xxxxxxxx110xx0xxxxxxxxxx
32038                                             sqrdmlah.  */
32039                                          return 438;
32040                                        }
32041                                    }
32042                                  else
32043                                    {
32044                                      /* 33222222222211111111110000000000
32045                                         10987654321098765432109876543210
32046                                         xx111111xxxxxxxx1x1xx0xxxxxxxxxx
32047                                         sqrdmlsh.  */
32048                                      return 439;
32049                                    }
32050                                }
32051                              else
32052                                {
32053                                  if (((word >> 11) & 0x1) == 0)
32054                                    {
32055                                      if (((word >> 12) & 0x1) == 0)
32056                                        {
32057                                          if (((word >> 13) & 0x1) == 0)
32058                                            {
32059                                              /* 33222222222211111111110000000000
32060                                                 10987654321098765432109876543210
32061                                                 xx111111xxxxxxxx1x0001xxxxxxxxxx
32062                                                 sqshrun.  */
32063                                              return 610;
32064                                            }
32065                                          else
32066                                            {
32067                                              /* 33222222222211111111110000000000
32068                                                 10987654321098765432109876543210
32069                                                 xx111111xxxxxxxx1x1001xxxxxxxxxx
32070                                                 ucvtf.  */
32071                                              return 614;
32072                                            }
32073                                        }
32074                                      else
32075                                        {
32076                                          /* 33222222222211111111110000000000
32077                                             10987654321098765432109876543210
32078                                             xx111111xxxxxxxx1xx101xxxxxxxxxx
32079                                             uqshrn.  */
32080                                          return 612;
32081                                        }
32082                                    }
32083                                  else
32084                                    {
32085                                      if (((word >> 12) & 0x1) == 0)
32086                                        {
32087                                          /* 33222222222211111111110000000000
32088                                             10987654321098765432109876543210
32089                                             xx111111xxxxxxxx1xx011xxxxxxxxxx
32090                                             sqrshrun.  */
32091                                          return 611;
32092                                        }
32093                                      else
32094                                        {
32095                                          if (((word >> 13) & 0x1) == 0)
32096                                            {
32097                                              /* 33222222222211111111110000000000
32098                                                 10987654321098765432109876543210
32099                                                 xx111111xxxxxxxx1x0111xxxxxxxxxx
32100                                                 uqrshrn.  */
32101                                              return 613;
32102                                            }
32103                                          else
32104                                            {
32105                                              /* 33222222222211111111110000000000
32106                                                 10987654321098765432109876543210
32107                                                 xx111111xxxxxxxx1x1111xxxxxxxxxx
32108                                                 fcvtzu.  */
32109                                              return 616;
32110                                            }
32111                                        }
32112                                    }
32113                                }
32114                            }
32115                        }
32116                    }
32117                }
32118            }
32119        }
32120    }
32121}
32122
32123/* Lookup opcode WORD in the opcode table.  N.B. all alias
32124   opcodes are ignored here.  */
32125
32126const aarch64_opcode *
32127aarch64_opcode_lookup (uint32_t word)
32128{
32129  return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
32130}
32131
32132const aarch64_opcode *
32133aarch64_find_next_opcode (const aarch64_opcode *opcode)
32134{
32135  /* Use the index as the key to locate the next opcode.  */
32136  int key = opcode - aarch64_opcode_table;
32137  int value;
32138  switch (key)
32139    {
32140    case 2426: value = 2428; break;	/* mov --> mova.  */
32141    case 2428: return NULL;		/* mova --> NULL.  */
32142    case 2425: value = 2427; break;	/* mov --> mova.  */
32143    case 2427: return NULL;		/* mova --> NULL.  */
32144    case 2667: value = 2675; break;	/* mov --> mova.  */
32145    case 2675: return NULL;		/* mova --> NULL.  */
32146    case 2663: value = 2671; break;	/* mov --> mova.  */
32147    case 2671: return NULL;		/* mova --> NULL.  */
32148    case 2665: value = 2673; break;	/* mov --> mova.  */
32149    case 2673: return NULL;		/* mova --> NULL.  */
32150    case 2661: value = 2669; break;	/* mov --> mova.  */
32151    case 2669: return NULL;		/* mova --> NULL.  */
32152    case 2668: value = 2676; break;	/* mov --> mova.  */
32153    case 2676: return NULL;		/* mova --> NULL.  */
32154    case 2664: value = 2672; break;	/* mov --> mova.  */
32155    case 2672: return NULL;		/* mova --> NULL.  */
32156    case 2666: value = 2674; break;	/* mov --> mova.  */
32157    case 2674: return NULL;		/* mova --> NULL.  */
32158    case 2662: value = 2670; break;	/* mov --> mova.  */
32159    case 2670: return NULL;		/* mova --> NULL.  */
32160    case 2430: value = 2435; break;	/* ld1b --> ld1b.  */
32161    case 2435: return NULL;		/* ld1b --> NULL.  */
32162    case 2432: value = 2437; break;	/* ld1w --> ld1w.  */
32163    case 2437: return NULL;		/* ld1w --> NULL.  */
32164    case 2431: value = 2436; break;	/* ld1h --> ld1h.  */
32165    case 2436: return NULL;		/* ld1h --> NULL.  */
32166    case 2433: value = 2438; break;	/* ld1d --> ld1d.  */
32167    case 2438: return NULL;		/* ld1d --> NULL.  */
32168    case 2440: value = 2445; break;	/* st1b --> st1b.  */
32169    case 2445: return NULL;		/* st1b --> NULL.  */
32170    case 2442: value = 2447; break;	/* st1w --> st1w.  */
32171    case 2447: return NULL;		/* st1w --> NULL.  */
32172    case 2441: value = 2446; break;	/* st1h --> st1h.  */
32173    case 2446: return NULL;		/* st1h --> NULL.  */
32174    case 2443: value = 2448; break;	/* st1d --> st1d.  */
32175    case 2448: return NULL;		/* st1d --> NULL.  */
32176    case 2434: value = 2439; break;	/* ld1q --> ld1q.  */
32177    case 2439: return NULL;		/* ld1q --> NULL.  */
32178    case 2444: value = 2449; break;	/* st1q --> st1q.  */
32179    case 2449: return NULL;		/* st1q --> NULL.  */
32180    case 12: value = 19; break;	/* add --> addg.  */
32181    case 19: value = 3194; break;	/* addg --> smax.  */
32182    case 3194: value = 3195; break;	/* smax --> umax.  */
32183    case 3195: value = 3196; break;	/* umax --> smin.  */
32184    case 3196: value = 3197; break;	/* smin --> umin.  */
32185    case 3197: return NULL;		/* umin --> NULL.  */
32186    case 16: value = 20; break;	/* sub --> subg.  */
32187    case 20: return NULL;		/* subg --> NULL.  */
32188    case 971: value = 975; break;	/* stnp --> stp.  */
32189    case 975: return NULL;		/* stp --> NULL.  */
32190    case 969: value = 970; break;	/* stllrb --> stllrh.  */
32191    case 970: return NULL;		/* stllrh --> NULL.  */
32192    case 972: value = 976; break;	/* ldnp --> ldp.  */
32193    case 976: return NULL;		/* ldp --> NULL.  */
32194    case 912: value = 2457; break;	/* prfm --> rprfm.  */
32195    case 2457: return NULL;		/* rprfm --> NULL.  */
32196    case 1679: value = 1680; break;	/* ldff1b --> ldff1b.  */
32197    case 1680: return NULL;		/* ldff1b --> NULL.  */
32198    case 1735: value = 1736; break;	/* ldff1sw --> ldff1sw.  */
32199    case 1736: return NULL;		/* ldff1sw --> NULL.  */
32200    case 1683: value = 1684; break;	/* ldff1b --> ldff1b.  */
32201    case 1684: return NULL;		/* ldff1b --> NULL.  */
32202    case 1702: value = 1703; break;	/* ldff1h --> ldff1h.  */
32203    case 1703: return NULL;		/* ldff1h --> NULL.  */
32204    case 1681: value = 1682; break;	/* ldff1b --> ldff1b.  */
32205    case 1682: return NULL;		/* ldff1b --> NULL.  */
32206    case 1700: value = 1701; break;	/* ldff1h --> ldff1h.  */
32207    case 1701: return NULL;		/* ldff1h --> NULL.  */
32208    case 1685: value = 1686; break;	/* ldff1b --> ldff1b.  */
32209    case 1686: return NULL;		/* ldff1b --> NULL.  */
32210    case 1704: value = 1705; break;	/* ldff1h --> ldff1h.  */
32211    case 1705: return NULL;		/* ldff1h --> NULL.  */
32212    case 1659: value = 3313; break;	/* ld2h --> ld2q.  */
32213    case 3313: return NULL;		/* ld2q --> NULL.  */
32214    case 2464: value = 3279; break;	/* fclamp --> bfclamp.  */
32215    case 3279: return NULL;		/* bfclamp --> NULL.  */
32216    case 1778: value = 1779; break;	/* ldr --> ldr.  */
32217    case 1779: return NULL;		/* ldr --> NULL.  */
32218    case 1434: value = 3278; break;	/* fadd --> bfadd.  */
32219    case 3278: return NULL;		/* bfadd --> NULL.  */
32220    case 1501: value = 3281; break;	/* fmul --> bfmul.  */
32221    case 3281: return NULL;		/* bfmul --> NULL.  */
32222    case 1527: value = 3283; break;	/* fsub --> bfsub.  */
32223    case 3283: return NULL;		/* bfsub --> NULL.  */
32224    case 1492: value = 3276; break;	/* fmla --> bfmla.  */
32225    case 3276: return NULL;		/* bfmla --> NULL.  */
32226    case 1997: value = 1998; break;	/* str --> str.  */
32227    case 1998: return NULL;		/* str --> NULL.  */
32228    case 1496: value = 3277; break;	/* fmls --> bfmls.  */
32229    case 3277: return NULL;		/* bfmls --> NULL.  */
32230    case 1725: value = 1726; break;	/* ldff1sh --> ldff1sh.  */
32231    case 1726: return NULL;		/* ldff1sh --> NULL.  */
32232    case 1713: value = 1714; break;	/* ldff1sb --> ldff1sb.  */
32233    case 1714: return NULL;		/* ldff1sb --> NULL.  */
32234    case 1744: value = 1745; break;	/* ldff1w --> ldff1w.  */
32235    case 1745: return NULL;		/* ldff1w --> NULL.  */
32236    case 1717: value = 1718; break;	/* ldff1sb --> ldff1sb.  */
32237    case 1718: return NULL;		/* ldff1sb --> NULL.  */
32238    case 2455: value = 2456; break;	/* psel --> psel.  */
32239    case 2456: return NULL;		/* psel --> NULL.  */
32240    case 1727: value = 1728; break;	/* ldff1sh --> ldff1sh.  */
32241    case 1728: return NULL;		/* ldff1sh --> NULL.  */
32242    case 1715: value = 1716; break;	/* ldff1sb --> ldff1sb.  */
32243    case 1716: return NULL;		/* ldff1sb --> NULL.  */
32244    case 1746: value = 1747; break;	/* ldff1w --> ldff1w.  */
32245    case 1747: return NULL;		/* ldff1w --> NULL.  */
32246    case 1691: value = 1692; break;	/* ldff1d --> ldff1d.  */
32247    case 1692: return NULL;		/* ldff1d --> NULL.  */
32248    case 1815: value = 1816; break;	/* pfalse --> pfalse.  */
32249    case 1816: return NULL;		/* pfalse --> NULL.  */
32250    case 1435: value = 3271; break;	/* fadd --> bfadd.  */
32251    case 3271: return NULL;		/* bfadd --> NULL.  */
32252    case 1482: value = 3273; break;	/* fmaxnm --> bfmaxnm.  */
32253    case 3273: return NULL;		/* bfmaxnm --> NULL.  */
32254    case 1502: value = 3280; break;	/* fmul --> bfmul.  */
32255    case 3280: return NULL;		/* bfmul --> NULL.  */
32256    case 1480: value = 3272; break;	/* fmax --> bfmax.  */
32257    case 3272: return NULL;		/* bfmax --> NULL.  */
32258    case 1528: value = 3282; break;	/* fsub --> bfsub.  */
32259    case 3282: return NULL;		/* bfsub --> NULL.  */
32260    case 1488: value = 3275; break;	/* fminnm --> bfminnm.  */
32261    case 3275: return NULL;		/* bfminnm --> NULL.  */
32262    case 1486: value = 3274; break;	/* fmin --> bfmin.  */
32263    case 3274: return NULL;		/* bfmin --> NULL.  */
32264    case 811: value = 812; break;	/* xaflag --> axflag.  */
32265    case 812: value = 1214; break;	/* axflag --> tcommit.  */
32266    case 1214: value = 1217; break;	/* tcommit --> smstart.  */
32267    case 1217: value = 1218; break;	/* smstart --> smstop.  */
32268    case 1218: value = 1219; break;	/* smstop --> smstart.  */
32269    case 1219: value = 1220; break;	/* smstart --> smstop.  */
32270    case 1220: value = 1221; break;	/* smstop --> chkfeat.  */
32271    case 1221: value = 1222; break;	/* chkfeat --> msr.  */
32272    case 1222: value = 1223; break;	/* msr --> hint.  */
32273    case 1223: value = 1232; break;	/* hint --> dgh.  */
32274    case 1232: value = 1242; break;	/* dgh --> clrex.  */
32275    case 1242: value = 1243; break;	/* clrex --> dsb.  */
32276    case 1243: value = 1244; break;	/* dsb --> dsb.  */
32277    case 1244: value = 1248; break;	/* dsb --> dmb.  */
32278    case 1248: value = 1249; break;	/* dmb --> isb.  */
32279    case 1249: value = 1250; break;	/* isb --> sb.  */
32280    case 1250: value = 1251; break;	/* sb --> gcspushx.  */
32281    case 1251: value = 1252; break;	/* gcspushx --> gcspopx.  */
32282    case 1252: value = 1253; break;	/* gcspopx --> gcspopcx.  */
32283    case 1253: value = 1254; break;	/* gcspopcx --> gcsss1.  */
32284    case 1254: value = 1255; break;	/* gcsss1 --> gcspushm.  */
32285    case 1255: value = 1262; break;	/* gcspushm --> sys.  */
32286    case 1262: value = 1269; break;	/* sys --> wfet.  */
32287    case 1269: value = 1270; break;	/* wfet --> wfit.  */
32288    case 1270: value = 1275; break;	/* wfit --> cfinv.  */
32289    case 1275: value = 1276; break;	/* cfinv --> msr.  */
32290    case 1276: return NULL;		/* msr --> NULL.  */
32291    case 1213: value = 1215; break;	/* tstart --> ttest.  */
32292    case 1215: value = 1256; break;	/* ttest --> gcsss2.  */
32293    case 1256: value = 1257; break;	/* gcsss2 --> gcspopm.  */
32294    case 1257: value = 1258; break;	/* gcspopm --> gcspopm.  */
32295    case 1258: value = 1277; break;	/* gcspopm --> sysl.  */
32296    case 1277: value = 1278; break;	/* sysl --> mrs.  */
32297    case 1278: return NULL;		/* mrs --> NULL.  */
32298    case 440: value = 441; break;	/* st4 --> st1.  */
32299    case 441: value = 442; break;	/* st1 --> st2.  */
32300    case 442: value = 443; break;	/* st2 --> st3.  */
32301    case 443: return NULL;		/* st3 --> NULL.  */
32302    case 448: value = 449; break;	/* st4 --> st1.  */
32303    case 449: value = 450; break;	/* st1 --> st2.  */
32304    case 450: value = 451; break;	/* st2 --> st3.  */
32305    case 451: return NULL;		/* st3 --> NULL.  */
32306    case 444: value = 445; break;	/* ld4 --> ld1.  */
32307    case 445: value = 446; break;	/* ld1 --> ld2.  */
32308    case 446: value = 447; break;	/* ld2 --> ld3.  */
32309    case 447: return NULL;		/* ld3 --> NULL.  */
32310    case 460: value = 462; break;	/* ld1 --> ld1r.  */
32311    case 462: return NULL;		/* ld1r --> NULL.  */
32312    case 464: value = 466; break;	/* ld2 --> ld2r.  */
32313    case 466: return NULL;		/* ld2r --> NULL.  */
32314    case 461: value = 463; break;	/* ld3 --> ld3r.  */
32315    case 463: return NULL;		/* ld3r --> NULL.  */
32316    case 465: value = 467; break;	/* ld4 --> ld4r.  */
32317    case 467: return NULL;		/* ld4r --> NULL.  */
32318    case 452: value = 453; break;	/* ld4 --> ld1.  */
32319    case 453: value = 454; break;	/* ld1 --> ld2.  */
32320    case 454: value = 455; break;	/* ld2 --> ld3.  */
32321    case 455: return NULL;		/* ld3 --> NULL.  */
32322    case 472: value = 474; break;	/* ld1 --> ld1r.  */
32323    case 474: return NULL;		/* ld1r --> NULL.  */
32324    case 473: value = 475; break;	/* ld3 --> ld3r.  */
32325    case 475: return NULL;		/* ld3r --> NULL.  */
32326    case 476: value = 478; break;	/* ld2 --> ld2r.  */
32327    case 478: return NULL;		/* ld2r --> NULL.  */
32328    case 477: value = 479; break;	/* ld4 --> ld4r.  */
32329    case 479: return NULL;		/* ld4r --> NULL.  */
32330    case 764: value = 765; break;	/* fcvtzs --> fcvtzs.  */
32331    case 765: return NULL;		/* fcvtzs --> NULL.  */
32332    case 760: value = 761; break;	/* scvtf --> scvtf.  */
32333    case 761: return NULL;		/* scvtf --> NULL.  */
32334    case 766: value = 767; break;	/* fcvtzu --> fcvtzu.  */
32335    case 767: return NULL;		/* fcvtzu --> NULL.  */
32336    case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
32337    case 763: return NULL;		/* ucvtf --> NULL.  */
32338    case 768: value = 769; break;	/* fcvtns --> fcvtns.  */
32339    case 769: return NULL;		/* fcvtns --> NULL.  */
32340    case 788: value = 789; break;	/* fcvtms --> fcvtms.  */
32341    case 789: return NULL;		/* fcvtms --> NULL.  */
32342    case 784: value = 785; break;	/* fcvtps --> fcvtps.  */
32343    case 785: return NULL;		/* fcvtps --> NULL.  */
32344    case 792: value = 793; break;	/* fcvtzs --> fcvtzs.  */
32345    case 793: return NULL;		/* fcvtzs --> NULL.  */
32346    case 776: value = 777; break;	/* fcvtas --> fcvtas.  */
32347    case 777: return NULL;		/* fcvtas --> NULL.  */
32348    case 772: value = 773; break;	/* scvtf --> scvtf.  */
32349    case 773: return NULL;		/* scvtf --> NULL.  */
32350    case 780: value = 781; break;	/* fmov --> fmov.  */
32351    case 781: return NULL;		/* fmov --> NULL.  */
32352    case 770: value = 771; break;	/* fcvtnu --> fcvtnu.  */
32353    case 771: return NULL;		/* fcvtnu --> NULL.  */
32354    case 790: value = 791; break;	/* fcvtmu --> fcvtmu.  */
32355    case 791: return NULL;		/* fcvtmu --> NULL.  */
32356    case 786: value = 787; break;	/* fcvtpu --> fcvtpu.  */
32357    case 787: return NULL;		/* fcvtpu --> NULL.  */
32358    case 794: value = 795; break;	/* fcvtzu --> fcvtzu.  */
32359    case 795: return NULL;		/* fcvtzu --> NULL.  */
32360    case 778: value = 779; break;	/* fcvtau --> fcvtau.  */
32361    case 779: return NULL;		/* fcvtau --> NULL.  */
32362    case 774: value = 775; break;	/* ucvtf --> ucvtf.  */
32363    case 775: return NULL;		/* ucvtf --> NULL.  */
32364    case 782: value = 783; break;	/* fmov --> fmov.  */
32365    case 783: return NULL;		/* fmov --> NULL.  */
32366    case 817: value = 818; break;	/* fmov --> fmov.  */
32367    case 818: return NULL;		/* fmov --> NULL.  */
32368    case 826: value = 827; break;	/* frintn --> frintn.  */
32369    case 827: return NULL;		/* frintn --> NULL.  */
32370    case 821: value = 822; break;	/* fneg --> fneg.  */
32371    case 822: return NULL;		/* fneg --> NULL.  */
32372    case 830: value = 831; break;	/* frintm --> frintm.  */
32373    case 831: return NULL;		/* frintm --> NULL.  */
32374    case 819: value = 820; break;	/* fabs --> fabs.  */
32375    case 820: return NULL;		/* fabs --> NULL.  */
32376    case 828: value = 829; break;	/* frintp --> frintp.  */
32377    case 829: return NULL;		/* frintp --> NULL.  */
32378    case 823: value = 824; break;	/* fsqrt --> fsqrt.  */
32379    case 824: return NULL;		/* fsqrt --> NULL.  */
32380    case 832: value = 833; break;	/* frintz --> frintz.  */
32381    case 833: return NULL;		/* frintz --> NULL.  */
32382    case 825: value = 3068; break;	/* fcvt --> bfcvt.  */
32383    case 3068: return NULL;		/* bfcvt --> NULL.  */
32384    case 834: value = 835; break;	/* frinta --> frinta.  */
32385    case 835: return NULL;		/* frinta --> NULL.  */
32386    case 836: value = 837; break;	/* frintx --> frintx.  */
32387    case 837: return NULL;		/* frintx --> NULL.  */
32388    case 838: value = 839; break;	/* frinti --> frinti.  */
32389    case 839: return NULL;		/* frinti --> NULL.  */
32390    case 803: value = 804; break;	/* fcmp --> fcmp.  */
32391    case 804: return NULL;		/* fcmp --> NULL.  */
32392    case 805: value = 806; break;	/* fcmpe --> fcmpe.  */
32393    case 806: return NULL;		/* fcmpe --> NULL.  */
32394    case 807: value = 808; break;	/* fcmp --> fcmp.  */
32395    case 808: return NULL;		/* fcmp --> NULL.  */
32396    case 809: value = 810; break;	/* fcmpe --> fcmpe.  */
32397    case 810: return NULL;		/* fcmpe --> NULL.  */
32398    case 866: value = 867; break;	/* fmov --> fmov.  */
32399    case 867: return NULL;		/* fmov --> NULL.  */
32400    case 840: value = 841; break;	/* fmul --> fmul.  */
32401    case 841: return NULL;		/* fmul --> NULL.  */
32402    case 856: value = 857; break;	/* fnmul --> fnmul.  */
32403    case 857: return NULL;		/* fnmul --> NULL.  */
32404    case 848: value = 849; break;	/* fmax --> fmax.  */
32405    case 849: return NULL;		/* fmax --> NULL.  */
32406    case 844: value = 845; break;	/* fadd --> fadd.  */
32407    case 845: return NULL;		/* fadd --> NULL.  */
32408    case 852: value = 853; break;	/* fmaxnm --> fmaxnm.  */
32409    case 853: return NULL;		/* fmaxnm --> NULL.  */
32410    case 842: value = 843; break;	/* fdiv --> fdiv.  */
32411    case 843: return NULL;		/* fdiv --> NULL.  */
32412    case 850: value = 851; break;	/* fmin --> fmin.  */
32413    case 851: return NULL;		/* fmin --> NULL.  */
32414    case 846: value = 847; break;	/* fsub --> fsub.  */
32415    case 847: return NULL;		/* fsub --> NULL.  */
32416    case 854: value = 855; break;	/* fminnm --> fminnm.  */
32417    case 855: return NULL;		/* fminnm --> NULL.  */
32418    case 799: value = 800; break;	/* fccmp --> fccmp.  */
32419    case 800: return NULL;		/* fccmp --> NULL.  */
32420    case 801: value = 802; break;	/* fccmpe --> fccmpe.  */
32421    case 802: return NULL;		/* fccmpe --> NULL.  */
32422    case 868: value = 869; break;	/* fcsel --> fcsel.  */
32423    case 869: return NULL;		/* fcsel --> NULL.  */
32424    case 133: value = 374; break;	/* movi --> sshr.  */
32425    case 374: value = 376; break;	/* sshr --> srshr.  */
32426    case 376: return NULL;		/* srshr --> NULL.  */
32427    case 141: value = 396; break;	/* mvni --> ushr.  */
32428    case 396: value = 398; break;	/* ushr --> urshr.  */
32429    case 398: value = 400; break;	/* urshr --> sri.  */
32430    case 400: value = 402; break;	/* sri --> sqshlu.  */
32431    case 402: return NULL;		/* sqshlu --> NULL.  */
32432    case 134: value = 375; break;	/* orr --> ssra.  */
32433    case 375: value = 377; break;	/* ssra --> srsra.  */
32434    case 377: value = 378; break;	/* srsra --> shl.  */
32435    case 378: value = 379; break;	/* shl --> sqshl.  */
32436    case 379: return NULL;		/* sqshl --> NULL.  */
32437    case 142: value = 397; break;	/* bic --> usra.  */
32438    case 397: value = 399; break;	/* usra --> ursra.  */
32439    case 399: value = 401; break;	/* ursra --> sli.  */
32440    case 401: value = 403; break;	/* sli --> uqshl.  */
32441    case 403: return NULL;		/* uqshl --> NULL.  */
32442    case 858: value = 859; break;	/* fmadd --> fmadd.  */
32443    case 859: return NULL;		/* fmadd --> NULL.  */
32444    case 862: value = 863; break;	/* fnmadd --> fnmadd.  */
32445    case 863: return NULL;		/* fnmadd --> NULL.  */
32446    case 135: value = 380; break;	/* movi --> shrn.  */
32447    case 380: value = 381; break;	/* shrn --> shrn2.  */
32448    case 381: value = 388; break;	/* shrn2 --> sshll.  */
32449    case 388: value = 390; break;	/* sshll --> sshll2.  */
32450    case 390: return NULL;		/* sshll2 --> NULL.  */
32451    case 143: value = 404; break;	/* mvni --> sqshrun.  */
32452    case 404: value = 405; break;	/* sqshrun --> sqshrun2.  */
32453    case 405: value = 412; break;	/* sqshrun2 --> ushll.  */
32454    case 412: value = 414; break;	/* ushll --> ushll2.  */
32455    case 414: return NULL;		/* ushll2 --> NULL.  */
32456    case 136: value = 384; break;	/* orr --> sqshrn.  */
32457    case 384: value = 385; break;	/* sqshrn --> sqshrn2.  */
32458    case 385: return NULL;		/* sqshrn2 --> NULL.  */
32459    case 144: value = 408; break;	/* bic --> uqshrn.  */
32460    case 408: value = 409; break;	/* uqshrn --> uqshrn2.  */
32461    case 409: return NULL;		/* uqshrn2 --> NULL.  */
32462    case 138: value = 392; break;	/* movi --> scvtf.  */
32463    case 392: value = 393; break;	/* scvtf --> scvtf.  */
32464    case 393: return NULL;		/* scvtf --> NULL.  */
32465    case 146: value = 147; break;	/* movi --> movi.  */
32466    case 147: value = 416; break;	/* movi --> ucvtf.  */
32467    case 416: value = 417; break;	/* ucvtf --> ucvtf.  */
32468    case 417: return NULL;		/* ucvtf --> NULL.  */
32469    case 140: value = 394; break;	/* fmov --> fcvtzs.  */
32470    case 394: value = 395; break;	/* fcvtzs --> fcvtzs.  */
32471    case 395: return NULL;		/* fcvtzs --> NULL.  */
32472    case 418: value = 419; break;	/* fcvtzu --> fcvtzu.  */
32473    case 419: return NULL;		/* fcvtzu --> NULL.  */
32474    case 860: value = 861; break;	/* fmsub --> fmsub.  */
32475    case 861: return NULL;		/* fmsub --> NULL.  */
32476    case 864: value = 865; break;	/* fnmsub --> fnmsub.  */
32477    case 865: return NULL;		/* fnmsub --> NULL.  */
32478    case 598: value = 599; break;	/* scvtf --> scvtf.  */
32479    case 599: return NULL;		/* scvtf --> NULL.  */
32480    case 600: value = 601; break;	/* fcvtzs --> fcvtzs.  */
32481    case 601: return NULL;		/* fcvtzs --> NULL.  */
32482    case 614: value = 615; break;	/* ucvtf --> ucvtf.  */
32483    case 615: return NULL;		/* ucvtf --> NULL.  */
32484    case 616: value = 617; break;	/* fcvtzu --> fcvtzu.  */
32485    case 617: return NULL;		/* fcvtzu --> NULL.  */
32486    default: return NULL;
32487    }
32488
32489  return aarch64_opcode_table + value;
32490}
32491
32492const aarch64_opcode *
32493aarch64_find_alias_opcode (const aarch64_opcode *opcode)
32494{
32495  /* Use the index as the key to locate the alias opcode.  */
32496  int key = opcode - aarch64_opcode_table;
32497  int value;
32498  switch (key)
32499    {
32500    case 2: value = 3; break;	/* sbc --> ngc.  */
32501    case 4: value = 5; break;	/* sbcs --> ngcs.  */
32502    case 7: value = 8; break;	/* adds --> cmn.  */
32503    case 10: value = 11; break;	/* subs --> cmp.  */
32504    case 12: value = 13; break;	/* add --> mov.  */
32505    case 14: value = 15; break;	/* adds --> cmn.  */
32506    case 17: value = 18; break;	/* subs --> cmp.  */
32507    case 22: value = 23; break;	/* adds --> cmn.  */
32508    case 24: value = 25; break;	/* sub --> neg.  */
32509    case 26: value = 27; break;	/* subs --> cmp.  */
32510    case 152: value = 153; break;	/* umov --> mov.  */
32511    case 154: value = 155; break;	/* ins --> mov.  */
32512    case 156: value = 157; break;	/* ins --> mov.  */
32513    case 242: value = 243; break;	/* not --> mvn.  */
32514    case 317: value = 318; break;	/* orr --> mov.  */
32515    case 388: value = 389; break;	/* sshll --> sxtl.  */
32516    case 390: value = 391; break;	/* sshll2 --> sxtl2.  */
32517    case 412: value = 413; break;	/* ushll --> uxtl.  */
32518    case 414: value = 415; break;	/* ushll2 --> uxtl2.  */
32519    case 535: value = 536; break;	/* dup --> mov.  */
32520    case 618: value = 623; break;	/* sbfm --> sxtw.  */
32521    case 625: value = 627; break;	/* bfm --> bfc.  */
32522    case 629: value = 633; break;	/* ubfm --> uxth.  */
32523    case 663: value = 665; break;	/* csinc --> cset.  */
32524    case 666: value = 668; break;	/* csinv --> csetm.  */
32525    case 669: value = 670; break;	/* csneg --> cneg.  */
32526    case 688: value = 688; break;	/* rev --> rev.  */
32527    case 713: value = 714; break;	/* lslv --> lsl.  */
32528    case 715: value = 716; break;	/* lsrv --> lsr.  */
32529    case 717: value = 718; break;	/* asrv --> asr.  */
32530    case 719: value = 720; break;	/* rorv --> ror.  */
32531    case 722: value = 723; break;	/* subps --> cmpp.  */
32532    case 735: value = 736; break;	/* madd --> mul.  */
32533    case 737: value = 738; break;	/* msub --> mneg.  */
32534    case 739: value = 740; break;	/* smaddl --> smull.  */
32535    case 741: value = 742; break;	/* smsubl --> smnegl.  */
32536    case 744: value = 745; break;	/* umaddl --> umull.  */
32537    case 746: value = 747; break;	/* umsubl --> umnegl.  */
32538    case 758: value = 759; break;	/* extr --> ror.  */
32539    case 995: value = 996; break;	/* and --> bic.  */
32540    case 997: value = 998; break;	/* orr --> mov.  */
32541    case 1000: value = 1001; break;	/* ands --> tst.  */
32542    case 1004: value = 1006; break;	/* orr --> uxtw.  */
32543    case 1007: value = 1008; break;	/* orn --> mvn.  */
32544    case 1011: value = 1012; break;	/* ands --> tst.  */
32545    case 1042: value = 1138; break;	/* ldaddb --> staddb.  */
32546    case 1043: value = 1139; break;	/* ldaddh --> staddh.  */
32547    case 1044: value = 1140; break;	/* ldadd --> stadd.  */
32548    case 1046: value = 1141; break;	/* ldaddlb --> staddlb.  */
32549    case 1049: value = 1142; break;	/* ldaddlh --> staddlh.  */
32550    case 1052: value = 1143; break;	/* ldaddl --> staddl.  */
32551    case 1054: value = 1144; break;	/* ldclrb --> stclrb.  */
32552    case 1055: value = 1145; break;	/* ldclrh --> stclrh.  */
32553    case 1056: value = 1146; break;	/* ldclr --> stclr.  */
32554    case 1058: value = 1147; break;	/* ldclrlb --> stclrlb.  */
32555    case 1061: value = 1148; break;	/* ldclrlh --> stclrlh.  */
32556    case 1064: value = 1149; break;	/* ldclrl --> stclrl.  */
32557    case 1066: value = 1150; break;	/* ldeorb --> steorb.  */
32558    case 1067: value = 1151; break;	/* ldeorh --> steorh.  */
32559    case 1068: value = 1152; break;	/* ldeor --> steor.  */
32560    case 1070: value = 1153; break;	/* ldeorlb --> steorlb.  */
32561    case 1073: value = 1154; break;	/* ldeorlh --> steorlh.  */
32562    case 1076: value = 1155; break;	/* ldeorl --> steorl.  */
32563    case 1078: value = 1156; break;	/* ldsetb --> stsetb.  */
32564    case 1079: value = 1157; break;	/* ldseth --> stseth.  */
32565    case 1080: value = 1158; break;	/* ldset --> stset.  */
32566    case 1082: value = 1159; break;	/* ldsetlb --> stsetlb.  */
32567    case 1085: value = 1160; break;	/* ldsetlh --> stsetlh.  */
32568    case 1088: value = 1161; break;	/* ldsetl --> stsetl.  */
32569    case 1090: value = 1162; break;	/* ldsmaxb --> stsmaxb.  */
32570    case 1091: value = 1163; break;	/* ldsmaxh --> stsmaxh.  */
32571    case 1092: value = 1164; break;	/* ldsmax --> stsmax.  */
32572    case 1094: value = 1165; break;	/* ldsmaxlb --> stsmaxlb.  */
32573    case 1097: value = 1166; break;	/* ldsmaxlh --> stsmaxlh.  */
32574    case 1100: value = 1167; break;	/* ldsmaxl --> stsmaxl.  */
32575    case 1102: value = 1168; break;	/* ldsminb --> stsminb.  */
32576    case 1103: value = 1169; break;	/* ldsminh --> stsminh.  */
32577    case 1104: value = 1170; break;	/* ldsmin --> stsmin.  */
32578    case 1106: value = 1171; break;	/* ldsminlb --> stsminlb.  */
32579    case 1109: value = 1172; break;	/* ldsminlh --> stsminlh.  */
32580    case 1112: value = 1173; break;	/* ldsminl --> stsminl.  */
32581    case 1114: value = 1174; break;	/* ldumaxb --> stumaxb.  */
32582    case 1115: value = 1175; break;	/* ldumaxh --> stumaxh.  */
32583    case 1116: value = 1176; break;	/* ldumax --> stumax.  */
32584    case 1118: value = 1177; break;	/* ldumaxlb --> stumaxlb.  */
32585    case 1121: value = 1178; break;	/* ldumaxlh --> stumaxlh.  */
32586    case 1124: value = 1179; break;	/* ldumaxl --> stumaxl.  */
32587    case 1126: value = 1180; break;	/* lduminb --> stuminb.  */
32588    case 1127: value = 1181; break;	/* lduminh --> stuminh.  */
32589    case 1128: value = 1182; break;	/* ldumin --> stumin.  */
32590    case 1130: value = 1183; break;	/* lduminlb --> stuminlb.  */
32591    case 1133: value = 1184; break;	/* lduminlh --> stuminlh.  */
32592    case 1136: value = 1185; break;	/* lduminl --> stuminl.  */
32593    case 1206: value = 1207; break;	/* movn --> mov.  */
32594    case 1208: value = 1209; break;	/* movz --> mov.  */
32595    case 1223: value = 3205; break;	/* hint --> clrbhb.  */
32596    case 1243: value = 1247; break;	/* dsb --> pssbb.  */
32597    case 1244: value = 1244; break;	/* dsb --> dsb.  */
32598    case 1262: value = 3206; break;	/* sys --> trcit.  */
32599    case 1263: value = 1268; break;	/* sysp --> tlbip.  */
32600    case 1269: value = 1269; break;	/* wfet --> wfet.  */
32601    case 1270: value = 1270; break;	/* wfit --> wfit.  */
32602    case 1337: value = 2090; break;	/* and --> bic.  */
32603    case 1339: value = 1320; break;	/* and --> mov.  */
32604    case 1340: value = 1324; break;	/* ands --> movs.  */
32605    case 1375: value = 2091; break;	/* cmpge --> cmple.  */
32606    case 1378: value = 2094; break;	/* cmpgt --> cmplt.  */
32607    case 1380: value = 2092; break;	/* cmphi --> cmplo.  */
32608    case 1383: value = 2093; break;	/* cmphs --> cmpls.  */
32609    case 1405: value = 1317; break;	/* cpy --> mov.  */
32610    case 1406: value = 1319; break;	/* cpy --> mov.  */
32611    case 1407: value = 2101; break;	/* cpy --> fmov.  */
32612    case 1419: value = 1311; break;	/* dup --> mov.  */
32613    case 1420: value = 1314; break;	/* dup --> mov.  */
32614    case 1421: value = 2100; break;	/* dup --> fmov.  */
32615    case 1422: value = 1315; break;	/* dupm --> mov.  */
32616    case 1424: value = 2095; break;	/* eor --> eon.  */
32617    case 1426: value = 1325; break;	/* eor --> not.  */
32618    case 1427: value = 1326; break;	/* eors --> nots.  */
32619    case 1432: value = 2096; break;	/* facge --> facle.  */
32620    case 1433: value = 2097; break;	/* facgt --> faclt.  */
32621    case 1446: value = 2098; break;	/* fcmge --> fcmle.  */
32622    case 1448: value = 2099; break;	/* fcmgt --> fcmlt.  */
32623    case 1454: value = 1308; break;	/* fcpy --> fmov.  */
32624    case 1477: value = 1307; break;	/* fdup --> fmov.  */
32625    case 1809: value = 1309; break;	/* orr --> mov.  */
32626    case 1810: value = 2102; break;	/* orr --> orn.  */
32627    case 1812: value = 1313; break;	/* orr --> mov.  */
32628    case 1813: value = 1323; break;	/* orrs --> movs.  */
32629    case 1876: value = 1318; break;	/* sel --> mov.  */
32630    case 1877: value = 1321; break;	/* sel --> mov.  */
32631    default: return NULL;
32632    }
32633
32634  return aarch64_opcode_table + value;
32635}
32636
32637const aarch64_opcode *
32638aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
32639{
32640  /* Use the index as the key to locate the next opcode.  */
32641  int key = opcode - aarch64_opcode_table;
32642  int value;
32643  switch (key)
32644    {
32645    case 3: value = 2; break;	/* ngc --> sbc.  */
32646    case 5: value = 4; break;	/* ngcs --> sbcs.  */
32647    case 8: value = 7; break;	/* cmn --> adds.  */
32648    case 11: value = 10; break;	/* cmp --> subs.  */
32649    case 13: value = 12; break;	/* mov --> add.  */
32650    case 15: value = 14; break;	/* cmn --> adds.  */
32651    case 18: value = 17; break;	/* cmp --> subs.  */
32652    case 23: value = 22; break;	/* cmn --> adds.  */
32653    case 25: value = 24; break;	/* neg --> sub.  */
32654    case 27: value = 28; break;	/* cmp --> negs.  */
32655    case 28: value = 26; break;	/* negs --> subs.  */
32656    case 153: value = 152; break;	/* mov --> umov.  */
32657    case 155: value = 154; break;	/* mov --> ins.  */
32658    case 157: value = 156; break;	/* mov --> ins.  */
32659    case 243: value = 242; break;	/* mvn --> not.  */
32660    case 318: value = 317; break;	/* mov --> orr.  */
32661    case 389: value = 388; break;	/* sxtl --> sshll.  */
32662    case 391: value = 390; break;	/* sxtl2 --> sshll2.  */
32663    case 413: value = 412; break;	/* uxtl --> ushll.  */
32664    case 415: value = 414; break;	/* uxtl2 --> ushll2.  */
32665    case 536: value = 535; break;	/* mov --> dup.  */
32666    case 623: value = 622; break;	/* sxtw --> sxth.  */
32667    case 622: value = 621; break;	/* sxth --> sxtb.  */
32668    case 621: value = 624; break;	/* sxtb --> asr.  */
32669    case 624: value = 620; break;	/* asr --> sbfx.  */
32670    case 620: value = 619; break;	/* sbfx --> sbfiz.  */
32671    case 619: value = 618; break;	/* sbfiz --> sbfm.  */
32672    case 627: value = 628; break;	/* bfc --> bfxil.  */
32673    case 628: value = 626; break;	/* bfxil --> bfi.  */
32674    case 626: value = 625; break;	/* bfi --> bfm.  */
32675    case 633: value = 632; break;	/* uxth --> uxtb.  */
32676    case 632: value = 635; break;	/* uxtb --> lsr.  */
32677    case 635: value = 634; break;	/* lsr --> lsl.  */
32678    case 634: value = 631; break;	/* lsl --> ubfx.  */
32679    case 631: value = 630; break;	/* ubfx --> ubfiz.  */
32680    case 630: value = 629; break;	/* ubfiz --> ubfm.  */
32681    case 665: value = 664; break;	/* cset --> cinc.  */
32682    case 664: value = 663; break;	/* cinc --> csinc.  */
32683    case 668: value = 667; break;	/* csetm --> cinv.  */
32684    case 667: value = 666; break;	/* cinv --> csinv.  */
32685    case 670: value = 669; break;	/* cneg --> csneg.  */
32686    case 688: value = 689; break;	/* rev --> rev64.  */
32687    case 714: value = 713; break;	/* lsl --> lslv.  */
32688    case 716: value = 715; break;	/* lsr --> lsrv.  */
32689    case 718: value = 717; break;	/* asr --> asrv.  */
32690    case 720: value = 719; break;	/* ror --> rorv.  */
32691    case 723: value = 722; break;	/* cmpp --> subps.  */
32692    case 736: value = 735; break;	/* mul --> madd.  */
32693    case 738: value = 737; break;	/* mneg --> msub.  */
32694    case 740: value = 739; break;	/* smull --> smaddl.  */
32695    case 742: value = 741; break;	/* smnegl --> smsubl.  */
32696    case 745: value = 744; break;	/* umull --> umaddl.  */
32697    case 747: value = 746; break;	/* umnegl --> umsubl.  */
32698    case 759: value = 758; break;	/* ror --> extr.  */
32699    case 996: value = 995; break;	/* bic --> and.  */
32700    case 998: value = 997; break;	/* mov --> orr.  */
32701    case 1001: value = 1000; break;	/* tst --> ands.  */
32702    case 1006: value = 1005; break;	/* uxtw --> mov.  */
32703    case 1005: value = 1004; break;	/* mov --> orr.  */
32704    case 1008: value = 1007; break;	/* mvn --> orn.  */
32705    case 1012: value = 1011; break;	/* tst --> ands.  */
32706    case 1138: value = 1042; break;	/* staddb --> ldaddb.  */
32707    case 1139: value = 1043; break;	/* staddh --> ldaddh.  */
32708    case 1140: value = 1044; break;	/* stadd --> ldadd.  */
32709    case 1141: value = 1046; break;	/* staddlb --> ldaddlb.  */
32710    case 1142: value = 1049; break;	/* staddlh --> ldaddlh.  */
32711    case 1143: value = 1052; break;	/* staddl --> ldaddl.  */
32712    case 1144: value = 1054; break;	/* stclrb --> ldclrb.  */
32713    case 1145: value = 1055; break;	/* stclrh --> ldclrh.  */
32714    case 1146: value = 1056; break;	/* stclr --> ldclr.  */
32715    case 1147: value = 1058; break;	/* stclrlb --> ldclrlb.  */
32716    case 1148: value = 1061; break;	/* stclrlh --> ldclrlh.  */
32717    case 1149: value = 1064; break;	/* stclrl --> ldclrl.  */
32718    case 1150: value = 1066; break;	/* steorb --> ldeorb.  */
32719    case 1151: value = 1067; break;	/* steorh --> ldeorh.  */
32720    case 1152: value = 1068; break;	/* steor --> ldeor.  */
32721    case 1153: value = 1070; break;	/* steorlb --> ldeorlb.  */
32722    case 1154: value = 1073; break;	/* steorlh --> ldeorlh.  */
32723    case 1155: value = 1076; break;	/* steorl --> ldeorl.  */
32724    case 1156: value = 1078; break;	/* stsetb --> ldsetb.  */
32725    case 1157: value = 1079; break;	/* stseth --> ldseth.  */
32726    case 1158: value = 1080; break;	/* stset --> ldset.  */
32727    case 1159: value = 1082; break;	/* stsetlb --> ldsetlb.  */
32728    case 1160: value = 1085; break;	/* stsetlh --> ldsetlh.  */
32729    case 1161: value = 1088; break;	/* stsetl --> ldsetl.  */
32730    case 1162: value = 1090; break;	/* stsmaxb --> ldsmaxb.  */
32731    case 1163: value = 1091; break;	/* stsmaxh --> ldsmaxh.  */
32732    case 1164: value = 1092; break;	/* stsmax --> ldsmax.  */
32733    case 1165: value = 1094; break;	/* stsmaxlb --> ldsmaxlb.  */
32734    case 1166: value = 1097; break;	/* stsmaxlh --> ldsmaxlh.  */
32735    case 1167: value = 1100; break;	/* stsmaxl --> ldsmaxl.  */
32736    case 1168: value = 1102; break;	/* stsminb --> ldsminb.  */
32737    case 1169: value = 1103; break;	/* stsminh --> ldsminh.  */
32738    case 1170: value = 1104; break;	/* stsmin --> ldsmin.  */
32739    case 1171: value = 1106; break;	/* stsminlb --> ldsminlb.  */
32740    case 1172: value = 1109; break;	/* stsminlh --> ldsminlh.  */
32741    case 1173: value = 1112; break;	/* stsminl --> ldsminl.  */
32742    case 1174: value = 1114; break;	/* stumaxb --> ldumaxb.  */
32743    case 1175: value = 1115; break;	/* stumaxh --> ldumaxh.  */
32744    case 1176: value = 1116; break;	/* stumax --> ldumax.  */
32745    case 1177: value = 1118; break;	/* stumaxlb --> ldumaxlb.  */
32746    case 1178: value = 1121; break;	/* stumaxlh --> ldumaxlh.  */
32747    case 1179: value = 1124; break;	/* stumaxl --> ldumaxl.  */
32748    case 1180: value = 1126; break;	/* stuminb --> lduminb.  */
32749    case 1181: value = 1127; break;	/* stuminh --> lduminh.  */
32750    case 1182: value = 1128; break;	/* stumin --> ldumin.  */
32751    case 1183: value = 1130; break;	/* stuminlb --> lduminlb.  */
32752    case 1184: value = 1133; break;	/* stuminlh --> lduminlh.  */
32753    case 1185: value = 1136; break;	/* stuminl --> lduminl.  */
32754    case 1207: value = 1206; break;	/* mov --> movn.  */
32755    case 1209: value = 1208; break;	/* mov --> movz.  */
32756    case 3205: value = 1288; break;	/* clrbhb --> autibsp.  */
32757    case 1288: value = 1287; break;	/* autibsp --> autibz.  */
32758    case 1287: value = 1286; break;	/* autibz --> autiasp.  */
32759    case 1286: value = 1285; break;	/* autiasp --> autiaz.  */
32760    case 1285: value = 1284; break;	/* autiaz --> pacibsp.  */
32761    case 1284: value = 1283; break;	/* pacibsp --> pacibz.  */
32762    case 1283: value = 1282; break;	/* pacibz --> paciasp.  */
32763    case 1282: value = 1281; break;	/* paciasp --> paciaz.  */
32764    case 1281: value = 1261; break;	/* paciaz --> gcsb.  */
32765    case 1261: value = 1241; break;	/* gcsb --> clearbhb.  */
32766    case 1241: value = 1240; break;	/* clearbhb --> tsb.  */
32767    case 1240: value = 1239; break;	/* tsb --> psb.  */
32768    case 1239: value = 1238; break;	/* psb --> esb.  */
32769    case 1238: value = 1237; break;	/* esb --> autib1716.  */
32770    case 1237: value = 1236; break;	/* autib1716 --> autia1716.  */
32771    case 1236: value = 1235; break;	/* autia1716 --> pacib1716.  */
32772    case 1235: value = 1234; break;	/* pacib1716 --> pacia1716.  */
32773    case 1234: value = 1233; break;	/* pacia1716 --> xpaclri.  */
32774    case 1233: value = 1231; break;	/* xpaclri --> sevl.  */
32775    case 1231: value = 1230; break;	/* sevl --> sev.  */
32776    case 1230: value = 1229; break;	/* sev --> wfi.  */
32777    case 1229: value = 1228; break;	/* wfi --> wfe.  */
32778    case 1228: value = 1227; break;	/* wfe --> yield.  */
32779    case 1227: value = 1226; break;	/* yield --> bti.  */
32780    case 1226: value = 1225; break;	/* bti --> csdb.  */
32781    case 1225: value = 1224; break;	/* csdb --> nop.  */
32782    case 1224: value = 1223; break;	/* nop --> hint.  */
32783    case 1247: value = 1246; break;	/* pssbb --> ssbb.  */
32784    case 1246: value = 1245; break;	/* ssbb --> dfb.  */
32785    case 1245: value = 1243; break;	/* dfb --> dsb.  */
32786    case 3206: value = 1274; break;	/* trcit --> cosp.  */
32787    case 1274: value = 1273; break;	/* cosp --> cpp.  */
32788    case 1273: value = 1272; break;	/* cpp --> dvp.  */
32789    case 1272: value = 1271; break;	/* dvp --> cfp.  */
32790    case 1271: value = 1267; break;	/* cfp --> tlbi.  */
32791    case 1267: value = 1266; break;	/* tlbi --> ic.  */
32792    case 1266: value = 1265; break;	/* ic --> dc.  */
32793    case 1265: value = 1264; break;	/* dc --> at.  */
32794    case 1264: value = 1262; break;	/* at --> sys.  */
32795    case 1268: value = 1263; break;	/* tlbip --> sysp.  */
32796    case 2090: value = 1337; break;	/* bic --> and.  */
32797    case 1320: value = 1339; break;	/* mov --> and.  */
32798    case 1324: value = 1340; break;	/* movs --> ands.  */
32799    case 2091: value = 1375; break;	/* cmple --> cmpge.  */
32800    case 2094: value = 1378; break;	/* cmplt --> cmpgt.  */
32801    case 2092: value = 1380; break;	/* cmplo --> cmphi.  */
32802    case 2093: value = 1383; break;	/* cmpls --> cmphs.  */
32803    case 1317: value = 1405; break;	/* mov --> cpy.  */
32804    case 1319: value = 1406; break;	/* mov --> cpy.  */
32805    case 2101: value = 1322; break;	/* fmov --> mov.  */
32806    case 1322: value = 1407; break;	/* mov --> cpy.  */
32807    case 1311: value = 1419; break;	/* mov --> dup.  */
32808    case 1314: value = 1310; break;	/* mov --> mov.  */
32809    case 1310: value = 1420; break;	/* mov --> dup.  */
32810    case 2100: value = 1316; break;	/* fmov --> mov.  */
32811    case 1316: value = 1421; break;	/* mov --> dup.  */
32812    case 1315: value = 1422; break;	/* mov --> dupm.  */
32813    case 2095: value = 1424; break;	/* eon --> eor.  */
32814    case 1325: value = 1426; break;	/* not --> eor.  */
32815    case 1326: value = 1427; break;	/* nots --> eors.  */
32816    case 2096: value = 1432; break;	/* facle --> facge.  */
32817    case 2097: value = 1433; break;	/* faclt --> facgt.  */
32818    case 2098: value = 1446; break;	/* fcmle --> fcmge.  */
32819    case 2099: value = 1448; break;	/* fcmlt --> fcmgt.  */
32820    case 1308: value = 1454; break;	/* fmov --> fcpy.  */
32821    case 1307: value = 1477; break;	/* fmov --> fdup.  */
32822    case 1309: value = 1809; break;	/* mov --> orr.  */
32823    case 2102: value = 1810; break;	/* orn --> orr.  */
32824    case 1313: value = 1312; break;	/* mov --> mov.  */
32825    case 1312: value = 1812; break;	/* mov --> orr.  */
32826    case 1323: value = 1813; break;	/* movs --> orrs.  */
32827    case 1318: value = 1876; break;	/* mov --> sel.  */
32828    case 1321: value = 1877; break;	/* mov --> sel.  */
32829    default: return NULL;
32830    }
32831
32832  return aarch64_opcode_table + value;
32833}
32834
32835bool
32836aarch64_extract_operand (const aarch64_operand *self,
32837			   aarch64_opnd_info *info,
32838			   aarch64_insn code, const aarch64_inst *inst,
32839			   aarch64_operand_error *errors)
32840{
32841  /* Use the index as the key.  */
32842  int key = self - aarch64_operands;
32843  switch (key)
32844    {
32845    case 1:
32846    case 2:
32847    case 3:
32848    case 4:
32849    case 5:
32850    case 7:
32851    case 8:
32852    case 9:
32853    case 10:
32854    case 12:
32855    case 13:
32856    case 14:
32857    case 19:
32858    case 20:
32859    case 21:
32860    case 22:
32861    case 24:
32862    case 25:
32863    case 26:
32864    case 27:
32865    case 28:
32866    case 29:
32867    case 30:
32868    case 31:
32869    case 32:
32870    case 33:
32871    case 116:
32872    case 117:
32873    case 175:
32874    case 176:
32875    case 177:
32876    case 178:
32877    case 179:
32878    case 180:
32879    case 181:
32880    case 182:
32881    case 183:
32882    case 184:
32883    case 185:
32884    case 186:
32885    case 187:
32886    case 188:
32887    case 203:
32888    case 204:
32889    case 205:
32890    case 206:
32891    case 215:
32892    case 216:
32893    case 217:
32894    case 218:
32895    case 219:
32896    case 227:
32897    case 231:
32898    case 235:
32899    case 242:
32900    case 243:
32901    case 250:
32902    case 251:
32903    case 252:
32904    case 253:
32905      return aarch64_ext_regno (self, info, code, inst, errors);
32906    case 6:
32907    case 113:
32908    case 114:
32909    case 285:
32910    case 287:
32911      return aarch64_ext_none (self, info, code, inst, errors);
32912    case 11:
32913      return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
32914    case 15:
32915    case 16:
32916      return aarch64_ext_regno_pair (self, info, code, inst, errors);
32917    case 17:
32918      return aarch64_ext_reg_extended (self, info, code, inst, errors);
32919    case 18:
32920      return aarch64_ext_reg_shifted (self, info, code, inst, errors);
32921    case 23:
32922      return aarch64_ext_ft (self, info, code, inst, errors);
32923    case 34:
32924    case 35:
32925    case 36:
32926    case 37:
32927    case 289:
32928      return aarch64_ext_reglane (self, info, code, inst, errors);
32929    case 38:
32930      return aarch64_ext_reglist (self, info, code, inst, errors);
32931    case 39:
32932      return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
32933    case 40:
32934      return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
32935    case 41:
32936      return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
32937    case 42:
32938    case 43:
32939    case 44:
32940    case 45:
32941    case 55:
32942    case 56:
32943    case 57:
32944    case 58:
32945    case 59:
32946    case 60:
32947    case 61:
32948    case 62:
32949    case 63:
32950    case 64:
32951    case 65:
32952    case 66:
32953    case 67:
32954    case 68:
32955    case 69:
32956    case 70:
32957    case 71:
32958    case 82:
32959    case 83:
32960    case 84:
32961    case 85:
32962    case 86:
32963    case 112:
32964    case 172:
32965    case 174:
32966    case 195:
32967    case 196:
32968    case 197:
32969    case 198:
32970    case 199:
32971    case 200:
32972    case 201:
32973    case 202:
32974    case 256:
32975    case 283:
32976    case 284:
32977    case 286:
32978    case 288:
32979    case 293:
32980    case 294:
32981      return aarch64_ext_imm (self, info, code, inst, errors);
32982    case 46:
32983    case 47:
32984      return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
32985    case 48:
32986    case 49:
32987    case 50:
32988      return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
32989    case 51:
32990      return aarch64_ext_shll_imm (self, info, code, inst, errors);
32991    case 54:
32992    case 162:
32993      return aarch64_ext_fpimm (self, info, code, inst, errors);
32994    case 72:
32995    case 170:
32996      return aarch64_ext_limm (self, info, code, inst, errors);
32997    case 73:
32998      return aarch64_ext_aimm (self, info, code, inst, errors);
32999    case 74:
33000      return aarch64_ext_imm_half (self, info, code, inst, errors);
33001    case 75:
33002      return aarch64_ext_fbits (self, info, code, inst, errors);
33003    case 77:
33004    case 78:
33005    case 167:
33006      return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
33007    case 79:
33008    case 166:
33009    case 168:
33010      return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
33011    case 80:
33012    case 81:
33013      return aarch64_ext_cond (self, info, code, inst, errors);
33014    case 87:
33015    case 96:
33016      return aarch64_ext_addr_simple (self, info, code, inst, errors);
33017    case 88:
33018      return aarch64_ext_addr_regoff (self, info, code, inst, errors);
33019    case 89:
33020    case 90:
33021    case 91:
33022    case 93:
33023    case 95:
33024      return aarch64_ext_addr_simm (self, info, code, inst, errors);
33025    case 92:
33026      return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
33027    case 94:
33028      return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
33029    case 97:
33030      return aarch64_ext_addr_offset (self, info, code, inst, errors);
33031    case 98:
33032      return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
33033    case 99:
33034    case 100:
33035      return aarch64_ext_sysreg (self, info, code, inst, errors);
33036    case 101:
33037      return aarch64_ext_pstatefield (self, info, code, inst, errors);
33038    case 102:
33039    case 103:
33040    case 104:
33041    case 105:
33042    case 106:
33043    case 107:
33044      return aarch64_ext_sysins_op (self, info, code, inst, errors);
33045    case 108:
33046    case 110:
33047      return aarch64_ext_barrier (self, info, code, inst, errors);
33048    case 109:
33049      return aarch64_ext_barrier_dsb_nxs (self, info, code, inst, errors);
33050    case 111:
33051      return aarch64_ext_prfop (self, info, code, inst, errors);
33052    case 115:
33053      return aarch64_ext_hint (self, info, code, inst, errors);
33054    case 118:
33055    case 119:
33056      return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
33057    case 120:
33058    case 121:
33059    case 122:
33060    case 123:
33061      return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
33062    case 124:
33063      return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
33064    case 125:
33065      return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
33066    case 126:
33067    case 127:
33068    case 128:
33069    case 129:
33070      return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
33071    case 130:
33072    case 131:
33073    case 132:
33074    case 133:
33075    case 134:
33076    case 135:
33077    case 136:
33078    case 137:
33079    case 138:
33080    case 139:
33081    case 140:
33082    case 141:
33083    case 142:
33084    case 143:
33085    case 144:
33086      return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
33087    case 145:
33088    case 146:
33089    case 147:
33090    case 148:
33091    case 149:
33092    case 150:
33093    case 151:
33094    case 152:
33095      return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
33096    case 153:
33097    case 154:
33098    case 155:
33099    case 156:
33100      return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
33101    case 157:
33102      return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
33103    case 158:
33104      return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
33105    case 159:
33106      return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
33107    case 160:
33108      return aarch64_ext_sve_aimm (self, info, code, inst, errors);
33109    case 161:
33110      return aarch64_ext_sve_asimm (self, info, code, inst, errors);
33111    case 163:
33112      return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
33113    case 164:
33114      return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
33115    case 165:
33116      return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
33117    case 169:
33118      return aarch64_ext_inv_limm (self, info, code, inst, errors);
33119    case 171:
33120      return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
33121    case 173:
33122      return aarch64_ext_sve_scale (self, info, code, inst, errors);
33123    case 189:
33124    case 190:
33125    case 191:
33126      return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
33127    case 192:
33128    case 193:
33129    case 194:
33130    case 269:
33131      return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
33132    case 207:
33133    case 208:
33134    case 209:
33135    case 210:
33136      return aarch64_ext_sme_za_vrs1 (self, info, code, inst, errors);
33137    case 211:
33138    case 212:
33139    case 213:
33140    case 214:
33141      return aarch64_ext_sme_za_vrs2 (self, info, code, inst, errors);
33142    case 220:
33143    case 221:
33144    case 222:
33145    case 223:
33146    case 224:
33147    case 225:
33148    case 226:
33149      return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
33150    case 228:
33151      return aarch64_ext_sve_index_imm (self, info, code, inst, errors);
33152    case 229:
33153      return aarch64_ext_sve_index (self, info, code, inst, errors);
33154    case 230:
33155    case 232:
33156    case 249:
33157      return aarch64_ext_sve_reglist (self, info, code, inst, errors);
33158    case 233:
33159    case 234:
33160    case 236:
33161    case 237:
33162    case 238:
33163    case 239:
33164    case 248:
33165      return aarch64_ext_sve_aligned_reglist (self, info, code, inst, errors);
33166    case 240:
33167    case 241:
33168      return aarch64_ext_sve_strided_reglist (self, info, code, inst, errors);
33169    case 244:
33170    case 246:
33171    case 257:
33172      return aarch64_ext_sme_za_hv_tiles (self, info, code, inst, errors);
33173    case 245:
33174    case 247:
33175      return aarch64_ext_sme_za_hv_tiles_range (self, info, code, inst, errors);
33176    case 254:
33177    case 255:
33178    case 270:
33179    case 271:
33180    case 272:
33181    case 273:
33182    case 274:
33183    case 275:
33184    case 276:
33185    case 277:
33186    case 278:
33187    case 279:
33188    case 280:
33189    case 281:
33190    case 282:
33191      return aarch64_ext_simple_index (self, info, code, inst, errors);
33192    case 258:
33193    case 259:
33194    case 260:
33195    case 261:
33196    case 262:
33197    case 263:
33198    case 264:
33199      return aarch64_ext_sme_za_array (self, info, code, inst, errors);
33200    case 265:
33201      return aarch64_ext_sme_addr_ri_u4xvl (self, info, code, inst, errors);
33202    case 266:
33203      return aarch64_ext_sme_sm_za (self, info, code, inst, errors);
33204    case 267:
33205      return aarch64_ext_sme_pred_reg_with_index (self, info, code, inst, errors);
33206    case 268:
33207      return aarch64_ext_plain_shrimm (self, info, code, inst, errors);
33208    case 290:
33209    case 291:
33210    case 292:
33211      return aarch64_ext_x0_to_x30 (self, info, code, inst, errors);
33212    case 295:
33213    case 296:
33214    case 297:
33215      return aarch64_ext_sve_reglist_zt (self, info, code, inst, errors);
33216    case 298:
33217    case 299:
33218    case 300:
33219    case 301:
33220      return aarch64_ext_rcpc3_addr_opt_offset (self, info, code, inst, errors);
33221    case 302:
33222      return aarch64_ext_rcpc3_addr_offset (self, info, code, inst, errors);
33223    default: assert (0); abort ();
33224    }
33225}
33226