1/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
2#line 1 "rx-decode.opc"
3/* -*- c -*- */
4/* Copyright (C) 2012-2022 Free Software Foundation, Inc.
5   Contributed by Red Hat.
6   Written by DJ Delorie.
7
8   This file is part of the GNU opcodes library.
9
10   This library is free software; you can redistribute it and/or modify
11   it under the terms of the GNU General Public License as published by
12   the Free Software Foundation; either version 3, or (at your option)
13   any later version.
14
15   It is distributed in the hope that it will be useful, but WITHOUT
16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18   License for more details.
19
20   You should have received a copy of the GNU General Public License
21   along with this program; if not, write to the Free Software
22   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23   MA 02110-1301, USA.  */
24
25#include "sysdep.h"
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include "ansidecl.h"
30#include "opcode/rx.h"
31#include "libiberty.h"
32
33#define RX_OPCODE_BIG_ENDIAN 0
34
35typedef struct
36{
37  RX_Opcode_Decoded * rx;
38  int (* getbyte)(void *);
39  void * ptr;
40  unsigned char * op;
41} LocalData;
42
43static int trace = 0;
44
45#define BSIZE 0
46#define WSIZE 1
47#define LSIZE 2
48#define DSIZE 3
49
50/* These are for when the upper bits are "don't care" or "undefined".  */
51static int bwl[4] =
52{
53  RX_Byte,
54  RX_Word,
55  RX_Long,
56  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
57};
58
59static int sbwl[4] =
60{
61  RX_SByte,
62  RX_SWord,
63  RX_Long,
64  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
65};
66
67static int ubw[4] =
68{
69  RX_UByte,
70  RX_UWord,
71  RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
72  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
73};
74
75static int memex[4] =
76{
77  RX_SByte,
78  RX_SWord,
79  RX_Long,
80  RX_UWord
81};
82
83static int _ld[2] =
84{
85  RX_Long,
86  RX_Double
87};
88
89#define ID(x) rx->id = RXO_##x
90#define OP(n,t,r,a) (rx->op[n].type = t, \
91		     rx->op[n].reg = r,	     \
92		     rx->op[n].addend = a )
93#define OPs(n,t,r,a,s) (OP (n,t,r,a), \
94			rx->op[n].size = s )
95
96/* This is for the BWL and BW bitfields.  */
97static int SCALE[] = { 1, 2, 4, 0 };
98/* This is for the prefix size enum.  */
99static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4, 8 };
100
101#define GET_SCALE(_indx)  ((unsigned)(_indx) < ARRAY_SIZE (SCALE) ? SCALE[(_indx)] : 0)
102#define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
103
104static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
105		       16, 17, 0, 0, 0, 0, 0, 0 };
106
107static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 };
108
109/*
110 *C	a constant (immediate) c
111 *R	A register
112 *I	Register indirect, no offset
113 *Is	Register indirect, with offset
114 *D	standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code
115 *P	standard displacement: type (r,[r]), reg, assumes UByte
116 *Pm	memex displacement: type (r,[r]), reg, memex code
117 *cc	condition code.  */
118
119#define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
120#define DR(r)       OP (0, RX_Operand_Register,  r, 0)
121#define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
122#define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
123#define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
124#define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
125#define DCR(r)      OP (0, RX_Operand_DoubleCReg, r, 0)
126#define DDR(r)      OP (0, RX_Operand_DoubleReg,  r, 0)
127#define DDRH(r)     OP (0, RX_Operand_DoubleRegH,  r, 0)
128#define DDRL(r)     OP (0, RX_Operand_DoubleRegL,  r, 0)
129#define DCND(r)     OP (0, RX_Operand_DoubleCond, r, 0)
130
131#define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
132#define SR(r)       OP (1, RX_Operand_Register,  r, 0)
133#define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
134#define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
135#define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
136#define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
137#define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
138#define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
139#define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
140#define SCR(r)      OP (1, RX_Operand_DoubleCReg, r, 0)
141#define SDR(r)      OP (1, RX_Operand_DoubleReg,  r, 0)
142#define SDRH(r)      OP (1, RX_Operand_DoubleRegH,  r, 0)
143#define SDRL(r)      OP (1, RX_Operand_DoubleRegL,  r, 0)
144
145#define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
146#define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
147#define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
148#define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
149#define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
150#define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
151#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
152#define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
153#define S2DR(r)     OP (2, RX_Operand_DoubleReg,  r, 0)
154#define S2CR(r)     OP (2, RX_Operand_DoubleCReg, r, 0)
155
156#define SDD(t,r,s)  rx_disp (1, t, r, bwl, ld);
157
158#define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
159#define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
160#define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
161#define P(t, n)	    rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
162#define DL(sz)      rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
163
164#define F(f) store_flags(rx, f)
165
166#define AU ATTRIBUTE_UNUSED
167#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
168
169#define SYNTAX(x) rx->syntax = x
170
171#define UNSUPPORTED() \
172  rx->syntax = "*unknown*"
173
174#define IMM(sf)   immediate (sf, 0, ld)
175#define IMMex(sf) immediate (sf, 1, ld)
176
177static int
178immediate (int sfield, int ex, LocalData * ld)
179{
180  unsigned long i = 0, j;
181
182  switch (sfield)
183    {
184#define B ((unsigned long) GETBYTE())
185    case 0:
186#if RX_OPCODE_BIG_ENDIAN
187      i  = B;
188      if (ex && (i & 0x80))
189	i -= 0x100;
190      i <<= 24;
191      i |= B << 16;
192      i |= B << 8;
193      i |= B;
194#else
195      i = B;
196      i |= B << 8;
197      i |= B << 16;
198      j = B;
199      if (ex && (j & 0x80))
200	j -= 0x100;
201      i |= j << 24;
202#endif
203      break;
204    case 3:
205#if RX_OPCODE_BIG_ENDIAN
206      i  = B << 16;
207      i |= B << 8;
208      i |= B;
209#else
210      i  = B;
211      i |= B << 8;
212      i |= B << 16;
213#endif
214      if (ex && (i & 0x800000))
215	i -= 0x1000000;
216      break;
217    case 2:
218#if RX_OPCODE_BIG_ENDIAN
219      i |= B << 8;
220      i |= B;
221#else
222      i |= B;
223      i |= B << 8;
224#endif
225      if (ex && (i & 0x8000))
226	i -= 0x10000;
227      break;
228    case 1:
229      i |= B;
230      if (ex && (i & 0x80))
231	i -= 0x100;
232      break;
233    default:
234      abort();
235    }
236  return i;
237}
238
239static void
240rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
241{
242  int disp;
243
244  ld->rx->op[n].reg = reg;
245  switch (type)
246    {
247    case 3:
248      ld->rx->op[n].type = RX_Operand_Register;
249      break;
250    case 0:
251      ld->rx->op[n].type = RX_Operand_Zero_Indirect;
252      ld->rx->op[n].addend = 0;
253      break;
254    case 1:
255      ld->rx->op[n].type = RX_Operand_Indirect;
256      disp = GETBYTE ();
257      ld->rx->op[n].addend = disp * GET_PSCALE (size);
258      break;
259    case 2:
260      ld->rx->op[n].type = RX_Operand_Indirect;
261      disp = GETBYTE ();
262#if RX_OPCODE_BIG_ENDIAN
263      disp = disp * 256 + GETBYTE ();
264#else
265      disp = disp + GETBYTE () * 256;
266#endif
267      ld->rx->op[n].addend = disp * GET_PSCALE (size);
268      break;
269    default:
270      abort ();
271    }
272}
273
274#define xO 8
275#define xS 4
276#define xZ 2
277#define xC 1
278
279#define F_____
280#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
281#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
282#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
283#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
284#define F_O___ rx->flags_0 = rx->flags_s = xO;
285#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
286#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
287#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
288
289int
290rx_decode_opcode (unsigned long pc AU,
291		  RX_Opcode_Decoded * rx,
292		  int (* getbyte)(void *),
293		  void * ptr)
294{
295  LocalData lds, * ld = &lds;
296  unsigned char op[20] = {0};
297
298  lds.rx = rx;
299  lds.getbyte = getbyte;
300  lds.ptr = ptr;
301  lds.op = op;
302
303  memset (rx, 0, sizeof (*rx));
304  BWL(LSIZE);
305
306
307/*----------------------------------------------------------------------*/
308/* MOV									*/
309
310  GETBYTE ();
311  switch (op[0] & 0xff)
312  {
313    case 0x00:
314        {
315          /** 0000 0000			brk */
316          if (trace)
317            {
318              printf ("\033[33m%s\033[0m  %02x\n",
319                     "/** 0000 0000			brk */",
320                     op[0]);
321            }
322          SYNTAX("brk");
323#line 1050 "rx-decode.opc"
324          ID(brk);
325
326        }
327      break;
328    case 0x01:
329        {
330          /** 0000 0001			dbt */
331          if (trace)
332            {
333              printf ("\033[33m%s\033[0m  %02x\n",
334                     "/** 0000 0001			dbt */",
335                     op[0]);
336            }
337          SYNTAX("dbt");
338#line 1053 "rx-decode.opc"
339          ID(dbt);
340
341        }
342      break;
343    case 0x02:
344        {
345          /** 0000 0010			rts */
346          if (trace)
347            {
348              printf ("\033[33m%s\033[0m  %02x\n",
349                     "/** 0000 0010			rts */",
350                     op[0]);
351            }
352          SYNTAX("rts");
353#line 831 "rx-decode.opc"
354          ID(rts);
355
356        /*----------------------------------------------------------------------*/
357        /* NOP								*/
358
359        }
360      break;
361    case 0x03:
362        {
363          /** 0000 0011			nop */
364          if (trace)
365            {
366              printf ("\033[33m%s\033[0m  %02x\n",
367                     "/** 0000 0011			nop */",
368                     op[0]);
369            }
370          SYNTAX("nop");
371#line 837 "rx-decode.opc"
372          ID(nop);
373
374        /*----------------------------------------------------------------------*/
375        /* STRING FUNCTIONS							*/
376
377        }
378      break;
379    case 0x04:
380        {
381          /** 0000 0100			bra.a	%a0 */
382          if (trace)
383            {
384              printf ("\033[33m%s\033[0m  %02x\n",
385                     "/** 0000 0100			bra.a	%a0 */",
386                     op[0]);
387            }
388          SYNTAX("bra.a	%a0");
389#line 809 "rx-decode.opc"
390          ID(branch); DC(pc + IMMex(3));
391
392        }
393      break;
394    case 0x05:
395        {
396          /** 0000 0101			bsr.a	%a0 */
397          if (trace)
398            {
399              printf ("\033[33m%s\033[0m  %02x\n",
400                     "/** 0000 0101			bsr.a	%a0 */",
401                     op[0]);
402            }
403          SYNTAX("bsr.a	%a0");
404#line 825 "rx-decode.opc"
405          ID(jsr); DC(pc + IMMex(3));
406
407        }
408      break;
409    case 0x06:
410        GETBYTE ();
411        switch (op[1] & 0xff)
412        {
413          case 0x00:
414              GETBYTE ();
415              switch (op[2] & 0x00)
416              {
417                case 0x00:
418                  op_semantics_1:
419                    {
420                      /** 0000 0110 mx00 00ss rsrc rdst			sub	%2%S2, %1 */
421#line 567 "rx-decode.opc"
422                      int mx AU = (op[1] >> 6) & 0x03;
423#line 567 "rx-decode.opc"
424                      int ss AU = op[1] & 0x03;
425#line 567 "rx-decode.opc"
426                      int rsrc AU = (op[2] >> 4) & 0x0f;
427#line 567 "rx-decode.opc"
428                      int rdst AU = op[2] & 0x0f;
429                      if (trace)
430                        {
431                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
432                                 "/** 0000 0110 mx00 00ss rsrc rdst			sub	%2%S2, %1 */",
433                                 op[0], op[1], op[2]);
434                          printf ("  mx = 0x%x,", mx);
435                          printf ("  ss = 0x%x,", ss);
436                          printf ("  rsrc = 0x%x,", rsrc);
437                          printf ("  rdst = 0x%x\n", rdst);
438                        }
439                      SYNTAX("sub	%2%S2, %1");
440#line 567 "rx-decode.opc"
441                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
442
443                    }
444                  break;
445              }
446            break;
447          case 0x01:
448              GETBYTE ();
449              switch (op[2] & 0x00)
450              {
451                case 0x00:
452                  goto op_semantics_1;
453                  break;
454              }
455            break;
456          case 0x02:
457              GETBYTE ();
458              switch (op[2] & 0x00)
459              {
460                case 0x00:
461                  goto op_semantics_1;
462                  break;
463              }
464            break;
465          case 0x03:
466              GETBYTE ();
467              switch (op[2] & 0x00)
468              {
469                case 0x00:
470                  goto op_semantics_1;
471                  break;
472              }
473            break;
474          case 0x04:
475              GETBYTE ();
476              switch (op[2] & 0x00)
477              {
478                case 0x00:
479                  op_semantics_2:
480                    {
481                      /** 0000 0110 mx00 01ss rsrc rdst		cmp	%2%S2, %1 */
482#line 555 "rx-decode.opc"
483                      int mx AU = (op[1] >> 6) & 0x03;
484#line 555 "rx-decode.opc"
485                      int ss AU = op[1] & 0x03;
486#line 555 "rx-decode.opc"
487                      int rsrc AU = (op[2] >> 4) & 0x0f;
488#line 555 "rx-decode.opc"
489                      int rdst AU = op[2] & 0x0f;
490                      if (trace)
491                        {
492                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
493                                 "/** 0000 0110 mx00 01ss rsrc rdst		cmp	%2%S2, %1 */",
494                                 op[0], op[1], op[2]);
495                          printf ("  mx = 0x%x,", mx);
496                          printf ("  ss = 0x%x,", ss);
497                          printf ("  rsrc = 0x%x,", rsrc);
498                          printf ("  rdst = 0x%x\n", rdst);
499                        }
500                      SYNTAX("cmp	%2%S2, %1");
501#line 555 "rx-decode.opc"
502                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
503
504                    /*----------------------------------------------------------------------*/
505                    /* SUB									*/
506
507                    }
508                  break;
509              }
510            break;
511          case 0x05:
512              GETBYTE ();
513              switch (op[2] & 0x00)
514              {
515                case 0x00:
516                  goto op_semantics_2;
517                  break;
518              }
519            break;
520          case 0x06:
521              GETBYTE ();
522              switch (op[2] & 0x00)
523              {
524                case 0x00:
525                  goto op_semantics_2;
526                  break;
527              }
528            break;
529          case 0x07:
530              GETBYTE ();
531              switch (op[2] & 0x00)
532              {
533                case 0x00:
534                  goto op_semantics_2;
535                  break;
536              }
537            break;
538          case 0x08:
539              GETBYTE ();
540              switch (op[2] & 0x00)
541              {
542                case 0x00:
543                  op_semantics_3:
544                    {
545                      /** 0000 0110 mx00 10ss rsrc rdst	add	%1%S1, %0 */
546#line 531 "rx-decode.opc"
547                      int mx AU = (op[1] >> 6) & 0x03;
548#line 531 "rx-decode.opc"
549                      int ss AU = op[1] & 0x03;
550#line 531 "rx-decode.opc"
551                      int rsrc AU = (op[2] >> 4) & 0x0f;
552#line 531 "rx-decode.opc"
553                      int rdst AU = op[2] & 0x0f;
554                      if (trace)
555                        {
556                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
557                                 "/** 0000 0110 mx00 10ss rsrc rdst	add	%1%S1, %0 */",
558                                 op[0], op[1], op[2]);
559                          printf ("  mx = 0x%x,", mx);
560                          printf ("  ss = 0x%x,", ss);
561                          printf ("  rsrc = 0x%x,", rsrc);
562                          printf ("  rdst = 0x%x\n", rdst);
563                        }
564                      SYNTAX("add	%1%S1, %0");
565#line 531 "rx-decode.opc"
566                      ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
567
568                    }
569                  break;
570              }
571            break;
572          case 0x09:
573              GETBYTE ();
574              switch (op[2] & 0x00)
575              {
576                case 0x00:
577                  goto op_semantics_3;
578                  break;
579              }
580            break;
581          case 0x0a:
582              GETBYTE ();
583              switch (op[2] & 0x00)
584              {
585                case 0x00:
586                  goto op_semantics_3;
587                  break;
588              }
589            break;
590          case 0x0b:
591              GETBYTE ();
592              switch (op[2] & 0x00)
593              {
594                case 0x00:
595                  goto op_semantics_3;
596                  break;
597              }
598            break;
599          case 0x0c:
600              GETBYTE ();
601              switch (op[2] & 0x00)
602              {
603                case 0x00:
604                  op_semantics_4:
605                    {
606                      /** 0000 0110 mx00 11ss rsrc rdst	mul	%1%S1, %0 */
607#line 674 "rx-decode.opc"
608                      int mx AU = (op[1] >> 6) & 0x03;
609#line 674 "rx-decode.opc"
610                      int ss AU = op[1] & 0x03;
611#line 674 "rx-decode.opc"
612                      int rsrc AU = (op[2] >> 4) & 0x0f;
613#line 674 "rx-decode.opc"
614                      int rdst AU = op[2] & 0x0f;
615                      if (trace)
616                        {
617                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
618                                 "/** 0000 0110 mx00 11ss rsrc rdst	mul	%1%S1, %0 */",
619                                 op[0], op[1], op[2]);
620                          printf ("  mx = 0x%x,", mx);
621                          printf ("  ss = 0x%x,", ss);
622                          printf ("  rsrc = 0x%x,", rsrc);
623                          printf ("  rdst = 0x%x\n", rdst);
624                        }
625                      SYNTAX("mul	%1%S1, %0");
626#line 674 "rx-decode.opc"
627                      ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
628
629                    }
630                  break;
631              }
632            break;
633          case 0x0d:
634              GETBYTE ();
635              switch (op[2] & 0x00)
636              {
637                case 0x00:
638                  goto op_semantics_4;
639                  break;
640              }
641            break;
642          case 0x0e:
643              GETBYTE ();
644              switch (op[2] & 0x00)
645              {
646                case 0x00:
647                  goto op_semantics_4;
648                  break;
649              }
650            break;
651          case 0x0f:
652              GETBYTE ();
653              switch (op[2] & 0x00)
654              {
655                case 0x00:
656                  goto op_semantics_4;
657                  break;
658              }
659            break;
660          case 0x10:
661              GETBYTE ();
662              switch (op[2] & 0x00)
663              {
664                case 0x00:
665                  op_semantics_5:
666                    {
667                      /** 0000 0110 mx01 00ss rsrc rdst	and	%1%S1, %0 */
668#line 444 "rx-decode.opc"
669                      int mx AU = (op[1] >> 6) & 0x03;
670#line 444 "rx-decode.opc"
671                      int ss AU = op[1] & 0x03;
672#line 444 "rx-decode.opc"
673                      int rsrc AU = (op[2] >> 4) & 0x0f;
674#line 444 "rx-decode.opc"
675                      int rdst AU = op[2] & 0x0f;
676                      if (trace)
677                        {
678                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
679                                 "/** 0000 0110 mx01 00ss rsrc rdst	and	%1%S1, %0 */",
680                                 op[0], op[1], op[2]);
681                          printf ("  mx = 0x%x,", mx);
682                          printf ("  ss = 0x%x,", ss);
683                          printf ("  rsrc = 0x%x,", rsrc);
684                          printf ("  rdst = 0x%x\n", rdst);
685                        }
686                      SYNTAX("and	%1%S1, %0");
687#line 444 "rx-decode.opc"
688                      ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
689
690                    }
691                  break;
692              }
693            break;
694          case 0x11:
695              GETBYTE ();
696              switch (op[2] & 0x00)
697              {
698                case 0x00:
699                  goto op_semantics_5;
700                  break;
701              }
702            break;
703          case 0x12:
704              GETBYTE ();
705              switch (op[2] & 0x00)
706              {
707                case 0x00:
708                  goto op_semantics_5;
709                  break;
710              }
711            break;
712          case 0x13:
713              GETBYTE ();
714              switch (op[2] & 0x00)
715              {
716                case 0x00:
717                  goto op_semantics_5;
718                  break;
719              }
720            break;
721          case 0x14:
722              GETBYTE ();
723              switch (op[2] & 0x00)
724              {
725                case 0x00:
726                  op_semantics_6:
727                    {
728                      /** 0000 0110 mx01 01ss rsrc rdst			or	%1%S1, %0 */
729#line 462 "rx-decode.opc"
730                      int mx AU = (op[1] >> 6) & 0x03;
731#line 462 "rx-decode.opc"
732                      int ss AU = op[1] & 0x03;
733#line 462 "rx-decode.opc"
734                      int rsrc AU = (op[2] >> 4) & 0x0f;
735#line 462 "rx-decode.opc"
736                      int rdst AU = op[2] & 0x0f;
737                      if (trace)
738                        {
739                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
740                                 "/** 0000 0110 mx01 01ss rsrc rdst			or	%1%S1, %0 */",
741                                 op[0], op[1], op[2]);
742                          printf ("  mx = 0x%x,", mx);
743                          printf ("  ss = 0x%x,", ss);
744                          printf ("  rsrc = 0x%x,", rsrc);
745                          printf ("  rdst = 0x%x\n", rdst);
746                        }
747                      SYNTAX("or	%1%S1, %0");
748#line 462 "rx-decode.opc"
749                      ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
750
751                    }
752                  break;
753              }
754            break;
755          case 0x15:
756              GETBYTE ();
757              switch (op[2] & 0x00)
758              {
759                case 0x00:
760                  goto op_semantics_6;
761                  break;
762              }
763            break;
764          case 0x16:
765              GETBYTE ();
766              switch (op[2] & 0x00)
767              {
768                case 0x00:
769                  goto op_semantics_6;
770                  break;
771              }
772            break;
773          case 0x17:
774              GETBYTE ();
775              switch (op[2] & 0x00)
776              {
777                case 0x00:
778                  goto op_semantics_6;
779                  break;
780              }
781            break;
782          case 0x20:
783              GETBYTE ();
784              switch (op[2] & 0xff)
785              {
786                case 0x00:
787                    GETBYTE ();
788                    switch (op[3] & 0x00)
789                    {
790                      case 0x00:
791                        op_semantics_7:
792                          {
793                            /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst	sbb	%1%S1, %0 */
794#line 580 "rx-decode.opc"
795                            int mx AU = (op[1] >> 6) & 0x03;
796#line 580 "rx-decode.opc"
797                            int sp AU = op[1] & 0x03;
798#line 580 "rx-decode.opc"
799                            int rsrc AU = (op[3] >> 4) & 0x0f;
800#line 580 "rx-decode.opc"
801                            int rdst AU = op[3] & 0x0f;
802                            if (trace)
803                              {
804                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
805                                       "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst	sbb	%1%S1, %0 */",
806                                       op[0], op[1], op[2], op[3]);
807                                printf ("  mx = 0x%x,", mx);
808                                printf ("  sp = 0x%x,", sp);
809                                printf ("  rsrc = 0x%x,", rsrc);
810                                printf ("  rdst = 0x%x\n", rdst);
811                              }
812                            SYNTAX("sbb	%1%S1, %0");
813#line 580 "rx-decode.opc"
814                            ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
815
816                          /*----------------------------------------------------------------------*/
817                          /* ABS									*/
818
819                          }
820                        break;
821                    }
822                  break;
823                case 0x04:
824                    GETBYTE ();
825                    switch (op[3] & 0x00)
826                    {
827                      case 0x00:
828                        op_semantics_8:
829                          {
830                            /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst	max	%1%S1, %0 */
831#line 619 "rx-decode.opc"
832                            int mx AU = (op[1] >> 6) & 0x03;
833#line 619 "rx-decode.opc"
834                            int ss AU = op[1] & 0x03;
835#line 619 "rx-decode.opc"
836                            int rsrc AU = (op[3] >> 4) & 0x0f;
837#line 619 "rx-decode.opc"
838                            int rdst AU = op[3] & 0x0f;
839                            if (trace)
840                              {
841                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
842                                       "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst	max	%1%S1, %0 */",
843                                       op[0], op[1], op[2], op[3]);
844                                printf ("  mx = 0x%x,", mx);
845                                printf ("  ss = 0x%x,", ss);
846                                printf ("  rsrc = 0x%x,", rsrc);
847                                printf ("  rdst = 0x%x\n", rdst);
848                              }
849                            SYNTAX("max	%1%S1, %0");
850#line 619 "rx-decode.opc"
851                            ID(max); SPm(ss, rsrc, mx); DR(rdst);
852
853                          /*----------------------------------------------------------------------*/
854                          /* MIN									*/
855
856                          }
857                        break;
858                    }
859                  break;
860                case 0x05:
861                    GETBYTE ();
862                    switch (op[3] & 0x00)
863                    {
864                      case 0x00:
865                        op_semantics_9:
866                          {
867                            /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst	min	%1%S1, %0 */
868#line 631 "rx-decode.opc"
869                            int mx AU = (op[1] >> 6) & 0x03;
870#line 631 "rx-decode.opc"
871                            int ss AU = op[1] & 0x03;
872#line 631 "rx-decode.opc"
873                            int rsrc AU = (op[3] >> 4) & 0x0f;
874#line 631 "rx-decode.opc"
875                            int rdst AU = op[3] & 0x0f;
876                            if (trace)
877                              {
878                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
879                                       "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst	min	%1%S1, %0 */",
880                                       op[0], op[1], op[2], op[3]);
881                                printf ("  mx = 0x%x,", mx);
882                                printf ("  ss = 0x%x,", ss);
883                                printf ("  rsrc = 0x%x,", rsrc);
884                                printf ("  rdst = 0x%x\n", rdst);
885                              }
886                            SYNTAX("min	%1%S1, %0");
887#line 631 "rx-decode.opc"
888                            ID(min); SPm(ss, rsrc, mx); DR(rdst);
889
890                          /*----------------------------------------------------------------------*/
891                          /* MUL									*/
892
893                          }
894                        break;
895                    }
896                  break;
897                case 0x06:
898                    GETBYTE ();
899                    switch (op[3] & 0x00)
900                    {
901                      case 0x00:
902                        op_semantics_10:
903                          {
904                            /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst	emul	%1%S1, %0 */
905#line 689 "rx-decode.opc"
906                            int mx AU = (op[1] >> 6) & 0x03;
907#line 689 "rx-decode.opc"
908                            int ss AU = op[1] & 0x03;
909#line 689 "rx-decode.opc"
910                            int rsrc AU = (op[3] >> 4) & 0x0f;
911#line 689 "rx-decode.opc"
912                            int rdst AU = op[3] & 0x0f;
913                            if (trace)
914                              {
915                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
916                                       "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst	emul	%1%S1, %0 */",
917                                       op[0], op[1], op[2], op[3]);
918                                printf ("  mx = 0x%x,", mx);
919                                printf ("  ss = 0x%x,", ss);
920                                printf ("  rsrc = 0x%x,", rsrc);
921                                printf ("  rdst = 0x%x\n", rdst);
922                              }
923                            SYNTAX("emul	%1%S1, %0");
924#line 689 "rx-decode.opc"
925                            ID(emul); SPm(ss, rsrc, mx); DR(rdst);
926
927                          /*----------------------------------------------------------------------*/
928                          /* EMULU									*/
929
930                          }
931                        break;
932                    }
933                  break;
934                case 0x07:
935                    GETBYTE ();
936                    switch (op[3] & 0x00)
937                    {
938                      case 0x00:
939                        op_semantics_11:
940                          {
941                            /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst	emulu	%1%S1, %0 */
942#line 701 "rx-decode.opc"
943                            int mx AU = (op[1] >> 6) & 0x03;
944#line 701 "rx-decode.opc"
945                            int ss AU = op[1] & 0x03;
946#line 701 "rx-decode.opc"
947                            int rsrc AU = (op[3] >> 4) & 0x0f;
948#line 701 "rx-decode.opc"
949                            int rdst AU = op[3] & 0x0f;
950                            if (trace)
951                              {
952                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
953                                       "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst	emulu	%1%S1, %0 */",
954                                       op[0], op[1], op[2], op[3]);
955                                printf ("  mx = 0x%x,", mx);
956                                printf ("  ss = 0x%x,", ss);
957                                printf ("  rsrc = 0x%x,", rsrc);
958                                printf ("  rdst = 0x%x\n", rdst);
959                              }
960                            SYNTAX("emulu	%1%S1, %0");
961#line 701 "rx-decode.opc"
962                            ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
963
964                          /*----------------------------------------------------------------------*/
965                          /* DIV									*/
966
967                          }
968                        break;
969                    }
970                  break;
971                case 0x08:
972                    GETBYTE ();
973                    switch (op[3] & 0x00)
974                    {
975                      case 0x00:
976                        op_semantics_12:
977                          {
978                            /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst	div	%1%S1, %0 */
979#line 713 "rx-decode.opc"
980                            int mx AU = (op[1] >> 6) & 0x03;
981#line 713 "rx-decode.opc"
982                            int ss AU = op[1] & 0x03;
983#line 713 "rx-decode.opc"
984                            int rsrc AU = (op[3] >> 4) & 0x0f;
985#line 713 "rx-decode.opc"
986                            int rdst AU = op[3] & 0x0f;
987                            if (trace)
988                              {
989                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
990                                       "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst	div	%1%S1, %0 */",
991                                       op[0], op[1], op[2], op[3]);
992                                printf ("  mx = 0x%x,", mx);
993                                printf ("  ss = 0x%x,", ss);
994                                printf ("  rsrc = 0x%x,", rsrc);
995                                printf ("  rdst = 0x%x\n", rdst);
996                              }
997                            SYNTAX("div	%1%S1, %0");
998#line 713 "rx-decode.opc"
999                            ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1000
1001                          /*----------------------------------------------------------------------*/
1002                          /* DIVU									*/
1003
1004                          }
1005                        break;
1006                    }
1007                  break;
1008                case 0x09:
1009                    GETBYTE ();
1010                    switch (op[3] & 0x00)
1011                    {
1012                      case 0x00:
1013                        op_semantics_13:
1014                          {
1015                            /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst	divu	%1%S1, %0 */
1016#line 725 "rx-decode.opc"
1017                            int mx AU = (op[1] >> 6) & 0x03;
1018#line 725 "rx-decode.opc"
1019                            int ss AU = op[1] & 0x03;
1020#line 725 "rx-decode.opc"
1021                            int rsrc AU = (op[3] >> 4) & 0x0f;
1022#line 725 "rx-decode.opc"
1023                            int rdst AU = op[3] & 0x0f;
1024                            if (trace)
1025                              {
1026                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1027                                       "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst	divu	%1%S1, %0 */",
1028                                       op[0], op[1], op[2], op[3]);
1029                                printf ("  mx = 0x%x,", mx);
1030                                printf ("  ss = 0x%x,", ss);
1031                                printf ("  rsrc = 0x%x,", rsrc);
1032                                printf ("  rdst = 0x%x\n", rdst);
1033                              }
1034                            SYNTAX("divu	%1%S1, %0");
1035#line 725 "rx-decode.opc"
1036                            ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1037
1038                          /*----------------------------------------------------------------------*/
1039                          /* SHIFT								*/
1040
1041                          }
1042                        break;
1043                    }
1044                  break;
1045                case 0x0c:
1046                    GETBYTE ();
1047                    switch (op[3] & 0x00)
1048                    {
1049                      case 0x00:
1050                        op_semantics_14:
1051                          {
1052                            /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst	tst	%1%S1, %2 */
1053#line 498 "rx-decode.opc"
1054                            int mx AU = (op[1] >> 6) & 0x03;
1055#line 498 "rx-decode.opc"
1056                            int ss AU = op[1] & 0x03;
1057#line 498 "rx-decode.opc"
1058                            int rsrc AU = (op[3] >> 4) & 0x0f;
1059#line 498 "rx-decode.opc"
1060                            int rdst AU = op[3] & 0x0f;
1061                            if (trace)
1062                              {
1063                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1064                                       "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst	tst	%1%S1, %2 */",
1065                                       op[0], op[1], op[2], op[3]);
1066                                printf ("  mx = 0x%x,", mx);
1067                                printf ("  ss = 0x%x,", ss);
1068                                printf ("  rsrc = 0x%x,", rsrc);
1069                                printf ("  rdst = 0x%x\n", rdst);
1070                              }
1071                            SYNTAX("tst	%1%S1, %2");
1072#line 498 "rx-decode.opc"
1073                            ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1074
1075                          /*----------------------------------------------------------------------*/
1076                          /* NEG									*/
1077
1078                          }
1079                        break;
1080                    }
1081                  break;
1082                case 0x0d:
1083                    GETBYTE ();
1084                    switch (op[3] & 0x00)
1085                    {
1086                      case 0x00:
1087                        op_semantics_15:
1088                          {
1089                            /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst	xor	%1%S1, %0 */
1090#line 477 "rx-decode.opc"
1091                            int mx AU = (op[1] >> 6) & 0x03;
1092#line 477 "rx-decode.opc"
1093                            int ss AU = op[1] & 0x03;
1094#line 477 "rx-decode.opc"
1095                            int rsrc AU = (op[3] >> 4) & 0x0f;
1096#line 477 "rx-decode.opc"
1097                            int rdst AU = op[3] & 0x0f;
1098                            if (trace)
1099                              {
1100                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1101                                       "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst	xor	%1%S1, %0 */",
1102                                       op[0], op[1], op[2], op[3]);
1103                                printf ("  mx = 0x%x,", mx);
1104                                printf ("  ss = 0x%x,", ss);
1105                                printf ("  rsrc = 0x%x,", rsrc);
1106                                printf ("  rdst = 0x%x\n", rdst);
1107                              }
1108                            SYNTAX("xor	%1%S1, %0");
1109#line 477 "rx-decode.opc"
1110                            ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1111
1112                          /*----------------------------------------------------------------------*/
1113                          /* NOT									*/
1114
1115                          }
1116                        break;
1117                    }
1118                  break;
1119                case 0x10:
1120                    GETBYTE ();
1121                    switch (op[3] & 0x00)
1122                    {
1123                      case 0x00:
1124                        op_semantics_16:
1125                          {
1126                            /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst	xchg	%1%S1, %0 */
1127#line 411 "rx-decode.opc"
1128                            int mx AU = (op[1] >> 6) & 0x03;
1129#line 411 "rx-decode.opc"
1130                            int ss AU = op[1] & 0x03;
1131#line 411 "rx-decode.opc"
1132                            int rsrc AU = (op[3] >> 4) & 0x0f;
1133#line 411 "rx-decode.opc"
1134                            int rdst AU = op[3] & 0x0f;
1135                            if (trace)
1136                              {
1137                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1138                                       "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst	xchg	%1%S1, %0 */",
1139                                       op[0], op[1], op[2], op[3]);
1140                                printf ("  mx = 0x%x,", mx);
1141                                printf ("  ss = 0x%x,", ss);
1142                                printf ("  rsrc = 0x%x,", rsrc);
1143                                printf ("  rdst = 0x%x\n", rdst);
1144                              }
1145                            SYNTAX("xchg	%1%S1, %0");
1146#line 411 "rx-decode.opc"
1147                            ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1148
1149                          /*----------------------------------------------------------------------*/
1150                          /* STZ/STNZ								*/
1151
1152                          }
1153                        break;
1154                    }
1155                  break;
1156                case 0x11:
1157                    GETBYTE ();
1158                    switch (op[3] & 0x00)
1159                    {
1160                      case 0x00:
1161                        op_semantics_17:
1162                          {
1163                            /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst	itof	%1%S1, %0 */
1164#line 954 "rx-decode.opc"
1165                            int mx AU = (op[1] >> 6) & 0x03;
1166#line 954 "rx-decode.opc"
1167                            int sd AU = op[1] & 0x03;
1168#line 954 "rx-decode.opc"
1169                            int rsrc AU = (op[3] >> 4) & 0x0f;
1170#line 954 "rx-decode.opc"
1171                            int rdst AU = op[3] & 0x0f;
1172                            if (trace)
1173                              {
1174                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1175                                       "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst	itof	%1%S1, %0 */",
1176                                       op[0], op[1], op[2], op[3]);
1177                                printf ("  mx = 0x%x,", mx);
1178                                printf ("  sd = 0x%x,", sd);
1179                                printf ("  rsrc = 0x%x,", rsrc);
1180                                printf ("  rdst = 0x%x\n", rdst);
1181                              }
1182                            SYNTAX("itof	%1%S1, %0");
1183#line 954 "rx-decode.opc"
1184                            ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1185
1186                          /*----------------------------------------------------------------------*/
1187                          /* BIT OPS								*/
1188
1189                          }
1190                        break;
1191                    }
1192                  break;
1193                case 0x15:
1194                    GETBYTE ();
1195                    switch (op[3] & 0x00)
1196                    {
1197                      case 0x00:
1198                        op_semantics_18:
1199                          {
1200                            /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst	utof	%1%S1, %0 */
1201#line 1140 "rx-decode.opc"
1202                            int mx AU = (op[1] >> 6) & 0x03;
1203#line 1140 "rx-decode.opc"
1204                            int sd AU = op[1] & 0x03;
1205#line 1140 "rx-decode.opc"
1206                            int rsrc AU = (op[3] >> 4) & 0x0f;
1207#line 1140 "rx-decode.opc"
1208                            int rdst AU = op[3] & 0x0f;
1209                            if (trace)
1210                              {
1211                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1212                                       "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst	utof	%1%S1, %0 */",
1213                                       op[0], op[1], op[2], op[3]);
1214                                printf ("  mx = 0x%x,", mx);
1215                                printf ("  sd = 0x%x,", sd);
1216                                printf ("  rsrc = 0x%x,", rsrc);
1217                                printf ("  rdst = 0x%x\n", rdst);
1218                              }
1219                            SYNTAX("utof	%1%S1, %0");
1220#line 1140 "rx-decode.opc"
1221                            ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1222
1223                          /*----------------------------------------------------------------------*/
1224                          /* RXv3 enhanced							*/
1225
1226                          }
1227                        break;
1228                    }
1229                  break;
1230                default: UNSUPPORTED(); break;
1231              }
1232            break;
1233          case 0x21:
1234              GETBYTE ();
1235              switch (op[2] & 0xff)
1236              {
1237                case 0x00:
1238                    GETBYTE ();
1239                    switch (op[3] & 0x00)
1240                    {
1241                      case 0x00:
1242                        goto op_semantics_7;
1243                        break;
1244                    }
1245                  break;
1246                case 0x04:
1247                    GETBYTE ();
1248                    switch (op[3] & 0x00)
1249                    {
1250                      case 0x00:
1251                        goto op_semantics_8;
1252                        break;
1253                    }
1254                  break;
1255                case 0x05:
1256                    GETBYTE ();
1257                    switch (op[3] & 0x00)
1258                    {
1259                      case 0x00:
1260                        goto op_semantics_9;
1261                        break;
1262                    }
1263                  break;
1264                case 0x06:
1265                    GETBYTE ();
1266                    switch (op[3] & 0x00)
1267                    {
1268                      case 0x00:
1269                        goto op_semantics_10;
1270                        break;
1271                    }
1272                  break;
1273                case 0x07:
1274                    GETBYTE ();
1275                    switch (op[3] & 0x00)
1276                    {
1277                      case 0x00:
1278                        goto op_semantics_11;
1279                        break;
1280                    }
1281                  break;
1282                case 0x08:
1283                    GETBYTE ();
1284                    switch (op[3] & 0x00)
1285                    {
1286                      case 0x00:
1287                        goto op_semantics_12;
1288                        break;
1289                    }
1290                  break;
1291                case 0x09:
1292                    GETBYTE ();
1293                    switch (op[3] & 0x00)
1294                    {
1295                      case 0x00:
1296                        goto op_semantics_13;
1297                        break;
1298                    }
1299                  break;
1300                case 0x0c:
1301                    GETBYTE ();
1302                    switch (op[3] & 0x00)
1303                    {
1304                      case 0x00:
1305                        goto op_semantics_14;
1306                        break;
1307                    }
1308                  break;
1309                case 0x0d:
1310                    GETBYTE ();
1311                    switch (op[3] & 0x00)
1312                    {
1313                      case 0x00:
1314                        goto op_semantics_15;
1315                        break;
1316                    }
1317                  break;
1318                case 0x10:
1319                    GETBYTE ();
1320                    switch (op[3] & 0x00)
1321                    {
1322                      case 0x00:
1323                        goto op_semantics_16;
1324                        break;
1325                    }
1326                  break;
1327                case 0x11:
1328                    GETBYTE ();
1329                    switch (op[3] & 0x00)
1330                    {
1331                      case 0x00:
1332                        goto op_semantics_17;
1333                        break;
1334                    }
1335                  break;
1336                case 0x15:
1337                    GETBYTE ();
1338                    switch (op[3] & 0x00)
1339                    {
1340                      case 0x00:
1341                        goto op_semantics_18;
1342                        break;
1343                    }
1344                  break;
1345                default: UNSUPPORTED(); break;
1346              }
1347            break;
1348          case 0x22:
1349              GETBYTE ();
1350              switch (op[2] & 0xff)
1351              {
1352                case 0x00:
1353                    GETBYTE ();
1354                    switch (op[3] & 0x00)
1355                    {
1356                      case 0x00:
1357                        goto op_semantics_7;
1358                        break;
1359                    }
1360                  break;
1361                case 0x04:
1362                    GETBYTE ();
1363                    switch (op[3] & 0x00)
1364                    {
1365                      case 0x00:
1366                        goto op_semantics_8;
1367                        break;
1368                    }
1369                  break;
1370                case 0x05:
1371                    GETBYTE ();
1372                    switch (op[3] & 0x00)
1373                    {
1374                      case 0x00:
1375                        goto op_semantics_9;
1376                        break;
1377                    }
1378                  break;
1379                case 0x06:
1380                    GETBYTE ();
1381                    switch (op[3] & 0x00)
1382                    {
1383                      case 0x00:
1384                        goto op_semantics_10;
1385                        break;
1386                    }
1387                  break;
1388                case 0x07:
1389                    GETBYTE ();
1390                    switch (op[3] & 0x00)
1391                    {
1392                      case 0x00:
1393                        goto op_semantics_11;
1394                        break;
1395                    }
1396                  break;
1397                case 0x08:
1398                    GETBYTE ();
1399                    switch (op[3] & 0x00)
1400                    {
1401                      case 0x00:
1402                        goto op_semantics_12;
1403                        break;
1404                    }
1405                  break;
1406                case 0x09:
1407                    GETBYTE ();
1408                    switch (op[3] & 0x00)
1409                    {
1410                      case 0x00:
1411                        goto op_semantics_13;
1412                        break;
1413                    }
1414                  break;
1415                case 0x0c:
1416                    GETBYTE ();
1417                    switch (op[3] & 0x00)
1418                    {
1419                      case 0x00:
1420                        goto op_semantics_14;
1421                        break;
1422                    }
1423                  break;
1424                case 0x0d:
1425                    GETBYTE ();
1426                    switch (op[3] & 0x00)
1427                    {
1428                      case 0x00:
1429                        goto op_semantics_15;
1430                        break;
1431                    }
1432                  break;
1433                case 0x10:
1434                    GETBYTE ();
1435                    switch (op[3] & 0x00)
1436                    {
1437                      case 0x00:
1438                        goto op_semantics_16;
1439                        break;
1440                    }
1441                  break;
1442                case 0x11:
1443                    GETBYTE ();
1444                    switch (op[3] & 0x00)
1445                    {
1446                      case 0x00:
1447                        goto op_semantics_17;
1448                        break;
1449                    }
1450                  break;
1451                case 0x15:
1452                    GETBYTE ();
1453                    switch (op[3] & 0x00)
1454                    {
1455                      case 0x00:
1456                        goto op_semantics_18;
1457                        break;
1458                    }
1459                  break;
1460                default: UNSUPPORTED(); break;
1461              }
1462            break;
1463          case 0x23:
1464              GETBYTE ();
1465              switch (op[2] & 0xff)
1466              {
1467                case 0x00:
1468                    GETBYTE ();
1469                    switch (op[3] & 0x00)
1470                    {
1471                      case 0x00:
1472                        goto op_semantics_7;
1473                        break;
1474                    }
1475                  break;
1476                case 0x04:
1477                    GETBYTE ();
1478                    switch (op[3] & 0x00)
1479                    {
1480                      case 0x00:
1481                        goto op_semantics_8;
1482                        break;
1483                    }
1484                  break;
1485                case 0x05:
1486                    GETBYTE ();
1487                    switch (op[3] & 0x00)
1488                    {
1489                      case 0x00:
1490                        goto op_semantics_9;
1491                        break;
1492                    }
1493                  break;
1494                case 0x06:
1495                    GETBYTE ();
1496                    switch (op[3] & 0x00)
1497                    {
1498                      case 0x00:
1499                        goto op_semantics_10;
1500                        break;
1501                    }
1502                  break;
1503                case 0x07:
1504                    GETBYTE ();
1505                    switch (op[3] & 0x00)
1506                    {
1507                      case 0x00:
1508                        goto op_semantics_11;
1509                        break;
1510                    }
1511                  break;
1512                case 0x08:
1513                    GETBYTE ();
1514                    switch (op[3] & 0x00)
1515                    {
1516                      case 0x00:
1517                        goto op_semantics_12;
1518                        break;
1519                    }
1520                  break;
1521                case 0x09:
1522                    GETBYTE ();
1523                    switch (op[3] & 0x00)
1524                    {
1525                      case 0x00:
1526                        goto op_semantics_13;
1527                        break;
1528                    }
1529                  break;
1530                case 0x0c:
1531                    GETBYTE ();
1532                    switch (op[3] & 0x00)
1533                    {
1534                      case 0x00:
1535                        goto op_semantics_14;
1536                        break;
1537                    }
1538                  break;
1539                case 0x0d:
1540                    GETBYTE ();
1541                    switch (op[3] & 0x00)
1542                    {
1543                      case 0x00:
1544                        goto op_semantics_15;
1545                        break;
1546                    }
1547                  break;
1548                case 0x10:
1549                    GETBYTE ();
1550                    switch (op[3] & 0x00)
1551                    {
1552                      case 0x00:
1553                        goto op_semantics_16;
1554                        break;
1555                    }
1556                  break;
1557                case 0x11:
1558                    GETBYTE ();
1559                    switch (op[3] & 0x00)
1560                    {
1561                      case 0x00:
1562                        goto op_semantics_17;
1563                        break;
1564                    }
1565                  break;
1566                case 0x15:
1567                    GETBYTE ();
1568                    switch (op[3] & 0x00)
1569                    {
1570                      case 0x00:
1571                        goto op_semantics_18;
1572                        break;
1573                    }
1574                  break;
1575                default: UNSUPPORTED(); break;
1576              }
1577            break;
1578          case 0x40:
1579              GETBYTE ();
1580              switch (op[2] & 0x00)
1581              {
1582                case 0x00:
1583                  goto op_semantics_1;
1584                  break;
1585              }
1586            break;
1587          case 0x41:
1588              GETBYTE ();
1589              switch (op[2] & 0x00)
1590              {
1591                case 0x00:
1592                  goto op_semantics_1;
1593                  break;
1594              }
1595            break;
1596          case 0x42:
1597              GETBYTE ();
1598              switch (op[2] & 0x00)
1599              {
1600                case 0x00:
1601                  goto op_semantics_1;
1602                  break;
1603              }
1604            break;
1605          case 0x43:
1606              GETBYTE ();
1607              switch (op[2] & 0x00)
1608              {
1609                case 0x00:
1610                  goto op_semantics_1;
1611                  break;
1612              }
1613            break;
1614          case 0x44:
1615              GETBYTE ();
1616              switch (op[2] & 0x00)
1617              {
1618                case 0x00:
1619                  goto op_semantics_2;
1620                  break;
1621              }
1622            break;
1623          case 0x45:
1624              GETBYTE ();
1625              switch (op[2] & 0x00)
1626              {
1627                case 0x00:
1628                  goto op_semantics_2;
1629                  break;
1630              }
1631            break;
1632          case 0x46:
1633              GETBYTE ();
1634              switch (op[2] & 0x00)
1635              {
1636                case 0x00:
1637                  goto op_semantics_2;
1638                  break;
1639              }
1640            break;
1641          case 0x47:
1642              GETBYTE ();
1643              switch (op[2] & 0x00)
1644              {
1645                case 0x00:
1646                  goto op_semantics_2;
1647                  break;
1648              }
1649            break;
1650          case 0x48:
1651              GETBYTE ();
1652              switch (op[2] & 0x00)
1653              {
1654                case 0x00:
1655                  goto op_semantics_3;
1656                  break;
1657              }
1658            break;
1659          case 0x49:
1660              GETBYTE ();
1661              switch (op[2] & 0x00)
1662              {
1663                case 0x00:
1664                  goto op_semantics_3;
1665                  break;
1666              }
1667            break;
1668          case 0x4a:
1669              GETBYTE ();
1670              switch (op[2] & 0x00)
1671              {
1672                case 0x00:
1673                  goto op_semantics_3;
1674                  break;
1675              }
1676            break;
1677          case 0x4b:
1678              GETBYTE ();
1679              switch (op[2] & 0x00)
1680              {
1681                case 0x00:
1682                  goto op_semantics_3;
1683                  break;
1684              }
1685            break;
1686          case 0x4c:
1687              GETBYTE ();
1688              switch (op[2] & 0x00)
1689              {
1690                case 0x00:
1691                  goto op_semantics_4;
1692                  break;
1693              }
1694            break;
1695          case 0x4d:
1696              GETBYTE ();
1697              switch (op[2] & 0x00)
1698              {
1699                case 0x00:
1700                  goto op_semantics_4;
1701                  break;
1702              }
1703            break;
1704          case 0x4e:
1705              GETBYTE ();
1706              switch (op[2] & 0x00)
1707              {
1708                case 0x00:
1709                  goto op_semantics_4;
1710                  break;
1711              }
1712            break;
1713          case 0x4f:
1714              GETBYTE ();
1715              switch (op[2] & 0x00)
1716              {
1717                case 0x00:
1718                  goto op_semantics_4;
1719                  break;
1720              }
1721            break;
1722          case 0x50:
1723              GETBYTE ();
1724              switch (op[2] & 0x00)
1725              {
1726                case 0x00:
1727                  goto op_semantics_5;
1728                  break;
1729              }
1730            break;
1731          case 0x51:
1732              GETBYTE ();
1733              switch (op[2] & 0x00)
1734              {
1735                case 0x00:
1736                  goto op_semantics_5;
1737                  break;
1738              }
1739            break;
1740          case 0x52:
1741              GETBYTE ();
1742              switch (op[2] & 0x00)
1743              {
1744                case 0x00:
1745                  goto op_semantics_5;
1746                  break;
1747              }
1748            break;
1749          case 0x53:
1750              GETBYTE ();
1751              switch (op[2] & 0x00)
1752              {
1753                case 0x00:
1754                  goto op_semantics_5;
1755                  break;
1756              }
1757            break;
1758          case 0x54:
1759              GETBYTE ();
1760              switch (op[2] & 0x00)
1761              {
1762                case 0x00:
1763                  goto op_semantics_6;
1764                  break;
1765              }
1766            break;
1767          case 0x55:
1768              GETBYTE ();
1769              switch (op[2] & 0x00)
1770              {
1771                case 0x00:
1772                  goto op_semantics_6;
1773                  break;
1774              }
1775            break;
1776          case 0x56:
1777              GETBYTE ();
1778              switch (op[2] & 0x00)
1779              {
1780                case 0x00:
1781                  goto op_semantics_6;
1782                  break;
1783              }
1784            break;
1785          case 0x57:
1786              GETBYTE ();
1787              switch (op[2] & 0x00)
1788              {
1789                case 0x00:
1790                  goto op_semantics_6;
1791                  break;
1792              }
1793            break;
1794          case 0x60:
1795              GETBYTE ();
1796              switch (op[2] & 0xff)
1797              {
1798                case 0x00:
1799                    GETBYTE ();
1800                    switch (op[3] & 0x00)
1801                    {
1802                      case 0x00:
1803                        goto op_semantics_7;
1804                        break;
1805                    }
1806                  break;
1807                case 0x04:
1808                    GETBYTE ();
1809                    switch (op[3] & 0x00)
1810                    {
1811                      case 0x00:
1812                        goto op_semantics_8;
1813                        break;
1814                    }
1815                  break;
1816                case 0x05:
1817                    GETBYTE ();
1818                    switch (op[3] & 0x00)
1819                    {
1820                      case 0x00:
1821                        goto op_semantics_9;
1822                        break;
1823                    }
1824                  break;
1825                case 0x06:
1826                    GETBYTE ();
1827                    switch (op[3] & 0x00)
1828                    {
1829                      case 0x00:
1830                        goto op_semantics_10;
1831                        break;
1832                    }
1833                  break;
1834                case 0x07:
1835                    GETBYTE ();
1836                    switch (op[3] & 0x00)
1837                    {
1838                      case 0x00:
1839                        goto op_semantics_11;
1840                        break;
1841                    }
1842                  break;
1843                case 0x08:
1844                    GETBYTE ();
1845                    switch (op[3] & 0x00)
1846                    {
1847                      case 0x00:
1848                        goto op_semantics_12;
1849                        break;
1850                    }
1851                  break;
1852                case 0x09:
1853                    GETBYTE ();
1854                    switch (op[3] & 0x00)
1855                    {
1856                      case 0x00:
1857                        goto op_semantics_13;
1858                        break;
1859                    }
1860                  break;
1861                case 0x0c:
1862                    GETBYTE ();
1863                    switch (op[3] & 0x00)
1864                    {
1865                      case 0x00:
1866                        goto op_semantics_14;
1867                        break;
1868                    }
1869                  break;
1870                case 0x0d:
1871                    GETBYTE ();
1872                    switch (op[3] & 0x00)
1873                    {
1874                      case 0x00:
1875                        goto op_semantics_15;
1876                        break;
1877                    }
1878                  break;
1879                case 0x10:
1880                    GETBYTE ();
1881                    switch (op[3] & 0x00)
1882                    {
1883                      case 0x00:
1884                        goto op_semantics_16;
1885                        break;
1886                    }
1887                  break;
1888                case 0x11:
1889                    GETBYTE ();
1890                    switch (op[3] & 0x00)
1891                    {
1892                      case 0x00:
1893                        goto op_semantics_17;
1894                        break;
1895                    }
1896                  break;
1897                case 0x15:
1898                    GETBYTE ();
1899                    switch (op[3] & 0x00)
1900                    {
1901                      case 0x00:
1902                        goto op_semantics_18;
1903                        break;
1904                    }
1905                  break;
1906                default: UNSUPPORTED(); break;
1907              }
1908            break;
1909          case 0x61:
1910              GETBYTE ();
1911              switch (op[2] & 0xff)
1912              {
1913                case 0x00:
1914                    GETBYTE ();
1915                    switch (op[3] & 0x00)
1916                    {
1917                      case 0x00:
1918                        goto op_semantics_7;
1919                        break;
1920                    }
1921                  break;
1922                case 0x04:
1923                    GETBYTE ();
1924                    switch (op[3] & 0x00)
1925                    {
1926                      case 0x00:
1927                        goto op_semantics_8;
1928                        break;
1929                    }
1930                  break;
1931                case 0x05:
1932                    GETBYTE ();
1933                    switch (op[3] & 0x00)
1934                    {
1935                      case 0x00:
1936                        goto op_semantics_9;
1937                        break;
1938                    }
1939                  break;
1940                case 0x06:
1941                    GETBYTE ();
1942                    switch (op[3] & 0x00)
1943                    {
1944                      case 0x00:
1945                        goto op_semantics_10;
1946                        break;
1947                    }
1948                  break;
1949                case 0x07:
1950                    GETBYTE ();
1951                    switch (op[3] & 0x00)
1952                    {
1953                      case 0x00:
1954                        goto op_semantics_11;
1955                        break;
1956                    }
1957                  break;
1958                case 0x08:
1959                    GETBYTE ();
1960                    switch (op[3] & 0x00)
1961                    {
1962                      case 0x00:
1963                        goto op_semantics_12;
1964                        break;
1965                    }
1966                  break;
1967                case 0x09:
1968                    GETBYTE ();
1969                    switch (op[3] & 0x00)
1970                    {
1971                      case 0x00:
1972                        goto op_semantics_13;
1973                        break;
1974                    }
1975                  break;
1976                case 0x0c:
1977                    GETBYTE ();
1978                    switch (op[3] & 0x00)
1979                    {
1980                      case 0x00:
1981                        goto op_semantics_14;
1982                        break;
1983                    }
1984                  break;
1985                case 0x0d:
1986                    GETBYTE ();
1987                    switch (op[3] & 0x00)
1988                    {
1989                      case 0x00:
1990                        goto op_semantics_15;
1991                        break;
1992                    }
1993                  break;
1994                case 0x10:
1995                    GETBYTE ();
1996                    switch (op[3] & 0x00)
1997                    {
1998                      case 0x00:
1999                        goto op_semantics_16;
2000                        break;
2001                    }
2002                  break;
2003                case 0x11:
2004                    GETBYTE ();
2005                    switch (op[3] & 0x00)
2006                    {
2007                      case 0x00:
2008                        goto op_semantics_17;
2009                        break;
2010                    }
2011                  break;
2012                case 0x15:
2013                    GETBYTE ();
2014                    switch (op[3] & 0x00)
2015                    {
2016                      case 0x00:
2017                        goto op_semantics_18;
2018                        break;
2019                    }
2020                  break;
2021                default: UNSUPPORTED(); break;
2022              }
2023            break;
2024          case 0x62:
2025              GETBYTE ();
2026              switch (op[2] & 0xff)
2027              {
2028                case 0x00:
2029                    GETBYTE ();
2030                    switch (op[3] & 0x00)
2031                    {
2032                      case 0x00:
2033                        goto op_semantics_7;
2034                        break;
2035                    }
2036                  break;
2037                case 0x04:
2038                    GETBYTE ();
2039                    switch (op[3] & 0x00)
2040                    {
2041                      case 0x00:
2042                        goto op_semantics_8;
2043                        break;
2044                    }
2045                  break;
2046                case 0x05:
2047                    GETBYTE ();
2048                    switch (op[3] & 0x00)
2049                    {
2050                      case 0x00:
2051                        goto op_semantics_9;
2052                        break;
2053                    }
2054                  break;
2055                case 0x06:
2056                    GETBYTE ();
2057                    switch (op[3] & 0x00)
2058                    {
2059                      case 0x00:
2060                        goto op_semantics_10;
2061                        break;
2062                    }
2063                  break;
2064                case 0x07:
2065                    GETBYTE ();
2066                    switch (op[3] & 0x00)
2067                    {
2068                      case 0x00:
2069                        goto op_semantics_11;
2070                        break;
2071                    }
2072                  break;
2073                case 0x08:
2074                    GETBYTE ();
2075                    switch (op[3] & 0x00)
2076                    {
2077                      case 0x00:
2078                        goto op_semantics_12;
2079                        break;
2080                    }
2081                  break;
2082                case 0x09:
2083                    GETBYTE ();
2084                    switch (op[3] & 0x00)
2085                    {
2086                      case 0x00:
2087                        goto op_semantics_13;
2088                        break;
2089                    }
2090                  break;
2091                case 0x0c:
2092                    GETBYTE ();
2093                    switch (op[3] & 0x00)
2094                    {
2095                      case 0x00:
2096                        goto op_semantics_14;
2097                        break;
2098                    }
2099                  break;
2100                case 0x0d:
2101                    GETBYTE ();
2102                    switch (op[3] & 0x00)
2103                    {
2104                      case 0x00:
2105                        goto op_semantics_15;
2106                        break;
2107                    }
2108                  break;
2109                case 0x10:
2110                    GETBYTE ();
2111                    switch (op[3] & 0x00)
2112                    {
2113                      case 0x00:
2114                        goto op_semantics_16;
2115                        break;
2116                    }
2117                  break;
2118                case 0x11:
2119                    GETBYTE ();
2120                    switch (op[3] & 0x00)
2121                    {
2122                      case 0x00:
2123                        goto op_semantics_17;
2124                        break;
2125                    }
2126                  break;
2127                case 0x15:
2128                    GETBYTE ();
2129                    switch (op[3] & 0x00)
2130                    {
2131                      case 0x00:
2132                        goto op_semantics_18;
2133                        break;
2134                    }
2135                  break;
2136                default: UNSUPPORTED(); break;
2137              }
2138            break;
2139          case 0x63:
2140              GETBYTE ();
2141              switch (op[2] & 0xff)
2142              {
2143                case 0x00:
2144                    GETBYTE ();
2145                    switch (op[3] & 0x00)
2146                    {
2147                      case 0x00:
2148                        goto op_semantics_7;
2149                        break;
2150                    }
2151                  break;
2152                case 0x04:
2153                    GETBYTE ();
2154                    switch (op[3] & 0x00)
2155                    {
2156                      case 0x00:
2157                        goto op_semantics_8;
2158                        break;
2159                    }
2160                  break;
2161                case 0x05:
2162                    GETBYTE ();
2163                    switch (op[3] & 0x00)
2164                    {
2165                      case 0x00:
2166                        goto op_semantics_9;
2167                        break;
2168                    }
2169                  break;
2170                case 0x06:
2171                    GETBYTE ();
2172                    switch (op[3] & 0x00)
2173                    {
2174                      case 0x00:
2175                        goto op_semantics_10;
2176                        break;
2177                    }
2178                  break;
2179                case 0x07:
2180                    GETBYTE ();
2181                    switch (op[3] & 0x00)
2182                    {
2183                      case 0x00:
2184                        goto op_semantics_11;
2185                        break;
2186                    }
2187                  break;
2188                case 0x08:
2189                    GETBYTE ();
2190                    switch (op[3] & 0x00)
2191                    {
2192                      case 0x00:
2193                        goto op_semantics_12;
2194                        break;
2195                    }
2196                  break;
2197                case 0x09:
2198                    GETBYTE ();
2199                    switch (op[3] & 0x00)
2200                    {
2201                      case 0x00:
2202                        goto op_semantics_13;
2203                        break;
2204                    }
2205                  break;
2206                case 0x0c:
2207                    GETBYTE ();
2208                    switch (op[3] & 0x00)
2209                    {
2210                      case 0x00:
2211                        goto op_semantics_14;
2212                        break;
2213                    }
2214                  break;
2215                case 0x0d:
2216                    GETBYTE ();
2217                    switch (op[3] & 0x00)
2218                    {
2219                      case 0x00:
2220                        goto op_semantics_15;
2221                        break;
2222                    }
2223                  break;
2224                case 0x10:
2225                    GETBYTE ();
2226                    switch (op[3] & 0x00)
2227                    {
2228                      case 0x00:
2229                        goto op_semantics_16;
2230                        break;
2231                    }
2232                  break;
2233                case 0x11:
2234                    GETBYTE ();
2235                    switch (op[3] & 0x00)
2236                    {
2237                      case 0x00:
2238                        goto op_semantics_17;
2239                        break;
2240                    }
2241                  break;
2242                case 0x15:
2243                    GETBYTE ();
2244                    switch (op[3] & 0x00)
2245                    {
2246                      case 0x00:
2247                        goto op_semantics_18;
2248                        break;
2249                    }
2250                  break;
2251                default: UNSUPPORTED(); break;
2252              }
2253            break;
2254          case 0x80:
2255              GETBYTE ();
2256              switch (op[2] & 0x00)
2257              {
2258                case 0x00:
2259                  goto op_semantics_1;
2260                  break;
2261              }
2262            break;
2263          case 0x81:
2264              GETBYTE ();
2265              switch (op[2] & 0x00)
2266              {
2267                case 0x00:
2268                  goto op_semantics_1;
2269                  break;
2270              }
2271            break;
2272          case 0x82:
2273              GETBYTE ();
2274              switch (op[2] & 0x00)
2275              {
2276                case 0x00:
2277                  goto op_semantics_1;
2278                  break;
2279              }
2280            break;
2281          case 0x83:
2282              GETBYTE ();
2283              switch (op[2] & 0x00)
2284              {
2285                case 0x00:
2286                  goto op_semantics_1;
2287                  break;
2288              }
2289            break;
2290          case 0x84:
2291              GETBYTE ();
2292              switch (op[2] & 0x00)
2293              {
2294                case 0x00:
2295                  goto op_semantics_2;
2296                  break;
2297              }
2298            break;
2299          case 0x85:
2300              GETBYTE ();
2301              switch (op[2] & 0x00)
2302              {
2303                case 0x00:
2304                  goto op_semantics_2;
2305                  break;
2306              }
2307            break;
2308          case 0x86:
2309              GETBYTE ();
2310              switch (op[2] & 0x00)
2311              {
2312                case 0x00:
2313                  goto op_semantics_2;
2314                  break;
2315              }
2316            break;
2317          case 0x87:
2318              GETBYTE ();
2319              switch (op[2] & 0x00)
2320              {
2321                case 0x00:
2322                  goto op_semantics_2;
2323                  break;
2324              }
2325            break;
2326          case 0x88:
2327              GETBYTE ();
2328              switch (op[2] & 0x00)
2329              {
2330                case 0x00:
2331                  goto op_semantics_3;
2332                  break;
2333              }
2334            break;
2335          case 0x89:
2336              GETBYTE ();
2337              switch (op[2] & 0x00)
2338              {
2339                case 0x00:
2340                  goto op_semantics_3;
2341                  break;
2342              }
2343            break;
2344          case 0x8a:
2345              GETBYTE ();
2346              switch (op[2] & 0x00)
2347              {
2348                case 0x00:
2349                  goto op_semantics_3;
2350                  break;
2351              }
2352            break;
2353          case 0x8b:
2354              GETBYTE ();
2355              switch (op[2] & 0x00)
2356              {
2357                case 0x00:
2358                  goto op_semantics_3;
2359                  break;
2360              }
2361            break;
2362          case 0x8c:
2363              GETBYTE ();
2364              switch (op[2] & 0x00)
2365              {
2366                case 0x00:
2367                  goto op_semantics_4;
2368                  break;
2369              }
2370            break;
2371          case 0x8d:
2372              GETBYTE ();
2373              switch (op[2] & 0x00)
2374              {
2375                case 0x00:
2376                  goto op_semantics_4;
2377                  break;
2378              }
2379            break;
2380          case 0x8e:
2381              GETBYTE ();
2382              switch (op[2] & 0x00)
2383              {
2384                case 0x00:
2385                  goto op_semantics_4;
2386                  break;
2387              }
2388            break;
2389          case 0x8f:
2390              GETBYTE ();
2391              switch (op[2] & 0x00)
2392              {
2393                case 0x00:
2394                  goto op_semantics_4;
2395                  break;
2396              }
2397            break;
2398          case 0x90:
2399              GETBYTE ();
2400              switch (op[2] & 0x00)
2401              {
2402                case 0x00:
2403                  goto op_semantics_5;
2404                  break;
2405              }
2406            break;
2407          case 0x91:
2408              GETBYTE ();
2409              switch (op[2] & 0x00)
2410              {
2411                case 0x00:
2412                  goto op_semantics_5;
2413                  break;
2414              }
2415            break;
2416          case 0x92:
2417              GETBYTE ();
2418              switch (op[2] & 0x00)
2419              {
2420                case 0x00:
2421                  goto op_semantics_5;
2422                  break;
2423              }
2424            break;
2425          case 0x93:
2426              GETBYTE ();
2427              switch (op[2] & 0x00)
2428              {
2429                case 0x00:
2430                  goto op_semantics_5;
2431                  break;
2432              }
2433            break;
2434          case 0x94:
2435              GETBYTE ();
2436              switch (op[2] & 0x00)
2437              {
2438                case 0x00:
2439                  goto op_semantics_6;
2440                  break;
2441              }
2442            break;
2443          case 0x95:
2444              GETBYTE ();
2445              switch (op[2] & 0x00)
2446              {
2447                case 0x00:
2448                  goto op_semantics_6;
2449                  break;
2450              }
2451            break;
2452          case 0x96:
2453              GETBYTE ();
2454              switch (op[2] & 0x00)
2455              {
2456                case 0x00:
2457                  goto op_semantics_6;
2458                  break;
2459              }
2460            break;
2461          case 0x97:
2462              GETBYTE ();
2463              switch (op[2] & 0x00)
2464              {
2465                case 0x00:
2466                  goto op_semantics_6;
2467                  break;
2468              }
2469            break;
2470          case 0xa0:
2471              GETBYTE ();
2472              switch (op[2] & 0xff)
2473              {
2474                case 0x00:
2475                    GETBYTE ();
2476                    switch (op[3] & 0x00)
2477                    {
2478                      case 0x00:
2479                        goto op_semantics_7;
2480                        break;
2481                    }
2482                  break;
2483                case 0x02:
2484                    GETBYTE ();
2485                    switch (op[3] & 0x00)
2486                    {
2487                      case 0x00:
2488                        op_semantics_19:
2489                          {
2490                            /** 0000 0110 1010 00ss 0000 0010 rsrc rdst	adc	%1%S1, %0 */
2491#line 519 "rx-decode.opc"
2492                            int ss AU = op[1] & 0x03;
2493#line 519 "rx-decode.opc"
2494                            int rsrc AU = (op[3] >> 4) & 0x0f;
2495#line 519 "rx-decode.opc"
2496                            int rdst AU = op[3] & 0x0f;
2497                            if (trace)
2498                              {
2499                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2500                                       "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst	adc	%1%S1, %0 */",
2501                                       op[0], op[1], op[2], op[3]);
2502                                printf ("  ss = 0x%x,", ss);
2503                                printf ("  rsrc = 0x%x,", rsrc);
2504                                printf ("  rdst = 0x%x\n", rdst);
2505                              }
2506                            SYNTAX("adc	%1%S1, %0");
2507#line 519 "rx-decode.opc"
2508                            ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2509
2510                          /*----------------------------------------------------------------------*/
2511                          /* ADD									*/
2512
2513                          }
2514                        break;
2515                    }
2516                  break;
2517                case 0x04:
2518                    GETBYTE ();
2519                    switch (op[3] & 0x00)
2520                    {
2521                      case 0x00:
2522                        goto op_semantics_8;
2523                        break;
2524                    }
2525                  break;
2526                case 0x05:
2527                    GETBYTE ();
2528                    switch (op[3] & 0x00)
2529                    {
2530                      case 0x00:
2531                        goto op_semantics_9;
2532                        break;
2533                    }
2534                  break;
2535                case 0x06:
2536                    GETBYTE ();
2537                    switch (op[3] & 0x00)
2538                    {
2539                      case 0x00:
2540                        goto op_semantics_10;
2541                        break;
2542                    }
2543                  break;
2544                case 0x07:
2545                    GETBYTE ();
2546                    switch (op[3] & 0x00)
2547                    {
2548                      case 0x00:
2549                        goto op_semantics_11;
2550                        break;
2551                    }
2552                  break;
2553                case 0x08:
2554                    GETBYTE ();
2555                    switch (op[3] & 0x00)
2556                    {
2557                      case 0x00:
2558                        goto op_semantics_12;
2559                        break;
2560                    }
2561                  break;
2562                case 0x09:
2563                    GETBYTE ();
2564                    switch (op[3] & 0x00)
2565                    {
2566                      case 0x00:
2567                        goto op_semantics_13;
2568                        break;
2569                    }
2570                  break;
2571                case 0x0c:
2572                    GETBYTE ();
2573                    switch (op[3] & 0x00)
2574                    {
2575                      case 0x00:
2576                        goto op_semantics_14;
2577                        break;
2578                    }
2579                  break;
2580                case 0x0d:
2581                    GETBYTE ();
2582                    switch (op[3] & 0x00)
2583                    {
2584                      case 0x00:
2585                        goto op_semantics_15;
2586                        break;
2587                    }
2588                  break;
2589                case 0x10:
2590                    GETBYTE ();
2591                    switch (op[3] & 0x00)
2592                    {
2593                      case 0x00:
2594                        goto op_semantics_16;
2595                        break;
2596                    }
2597                  break;
2598                case 0x11:
2599                    GETBYTE ();
2600                    switch (op[3] & 0x00)
2601                    {
2602                      case 0x00:
2603                        goto op_semantics_17;
2604                        break;
2605                    }
2606                  break;
2607                case 0x15:
2608                    GETBYTE ();
2609                    switch (op[3] & 0x00)
2610                    {
2611                      case 0x00:
2612                        goto op_semantics_18;
2613                        break;
2614                    }
2615                  break;
2616                default: UNSUPPORTED(); break;
2617              }
2618            break;
2619          case 0xa1:
2620              GETBYTE ();
2621              switch (op[2] & 0xff)
2622              {
2623                case 0x00:
2624                    GETBYTE ();
2625                    switch (op[3] & 0x00)
2626                    {
2627                      case 0x00:
2628                        goto op_semantics_7;
2629                        break;
2630                    }
2631                  break;
2632                case 0x02:
2633                    GETBYTE ();
2634                    switch (op[3] & 0x00)
2635                    {
2636                      case 0x00:
2637                        goto op_semantics_19;
2638                        break;
2639                    }
2640                  break;
2641                case 0x04:
2642                    GETBYTE ();
2643                    switch (op[3] & 0x00)
2644                    {
2645                      case 0x00:
2646                        goto op_semantics_8;
2647                        break;
2648                    }
2649                  break;
2650                case 0x05:
2651                    GETBYTE ();
2652                    switch (op[3] & 0x00)
2653                    {
2654                      case 0x00:
2655                        goto op_semantics_9;
2656                        break;
2657                    }
2658                  break;
2659                case 0x06:
2660                    GETBYTE ();
2661                    switch (op[3] & 0x00)
2662                    {
2663                      case 0x00:
2664                        goto op_semantics_10;
2665                        break;
2666                    }
2667                  break;
2668                case 0x07:
2669                    GETBYTE ();
2670                    switch (op[3] & 0x00)
2671                    {
2672                      case 0x00:
2673                        goto op_semantics_11;
2674                        break;
2675                    }
2676                  break;
2677                case 0x08:
2678                    GETBYTE ();
2679                    switch (op[3] & 0x00)
2680                    {
2681                      case 0x00:
2682                        goto op_semantics_12;
2683                        break;
2684                    }
2685                  break;
2686                case 0x09:
2687                    GETBYTE ();
2688                    switch (op[3] & 0x00)
2689                    {
2690                      case 0x00:
2691                        goto op_semantics_13;
2692                        break;
2693                    }
2694                  break;
2695                case 0x0c:
2696                    GETBYTE ();
2697                    switch (op[3] & 0x00)
2698                    {
2699                      case 0x00:
2700                        goto op_semantics_14;
2701                        break;
2702                    }
2703                  break;
2704                case 0x0d:
2705                    GETBYTE ();
2706                    switch (op[3] & 0x00)
2707                    {
2708                      case 0x00:
2709                        goto op_semantics_15;
2710                        break;
2711                    }
2712                  break;
2713                case 0x10:
2714                    GETBYTE ();
2715                    switch (op[3] & 0x00)
2716                    {
2717                      case 0x00:
2718                        goto op_semantics_16;
2719                        break;
2720                    }
2721                  break;
2722                case 0x11:
2723                    GETBYTE ();
2724                    switch (op[3] & 0x00)
2725                    {
2726                      case 0x00:
2727                        goto op_semantics_17;
2728                        break;
2729                    }
2730                  break;
2731                case 0x15:
2732                    GETBYTE ();
2733                    switch (op[3] & 0x00)
2734                    {
2735                      case 0x00:
2736                        goto op_semantics_18;
2737                        break;
2738                    }
2739                  break;
2740                default: UNSUPPORTED(); break;
2741              }
2742            break;
2743          case 0xa2:
2744              GETBYTE ();
2745              switch (op[2] & 0xff)
2746              {
2747                case 0x00:
2748                    GETBYTE ();
2749                    switch (op[3] & 0x00)
2750                    {
2751                      case 0x00:
2752                        goto op_semantics_7;
2753                        break;
2754                    }
2755                  break;
2756                case 0x02:
2757                    GETBYTE ();
2758                    switch (op[3] & 0x00)
2759                    {
2760                      case 0x00:
2761                        goto op_semantics_19;
2762                        break;
2763                    }
2764                  break;
2765                case 0x04:
2766                    GETBYTE ();
2767                    switch (op[3] & 0x00)
2768                    {
2769                      case 0x00:
2770                        goto op_semantics_8;
2771                        break;
2772                    }
2773                  break;
2774                case 0x05:
2775                    GETBYTE ();
2776                    switch (op[3] & 0x00)
2777                    {
2778                      case 0x00:
2779                        goto op_semantics_9;
2780                        break;
2781                    }
2782                  break;
2783                case 0x06:
2784                    GETBYTE ();
2785                    switch (op[3] & 0x00)
2786                    {
2787                      case 0x00:
2788                        goto op_semantics_10;
2789                        break;
2790                    }
2791                  break;
2792                case 0x07:
2793                    GETBYTE ();
2794                    switch (op[3] & 0x00)
2795                    {
2796                      case 0x00:
2797                        goto op_semantics_11;
2798                        break;
2799                    }
2800                  break;
2801                case 0x08:
2802                    GETBYTE ();
2803                    switch (op[3] & 0x00)
2804                    {
2805                      case 0x00:
2806                        goto op_semantics_12;
2807                        break;
2808                    }
2809                  break;
2810                case 0x09:
2811                    GETBYTE ();
2812                    switch (op[3] & 0x00)
2813                    {
2814                      case 0x00:
2815                        goto op_semantics_13;
2816                        break;
2817                    }
2818                  break;
2819                case 0x0c:
2820                    GETBYTE ();
2821                    switch (op[3] & 0x00)
2822                    {
2823                      case 0x00:
2824                        goto op_semantics_14;
2825                        break;
2826                    }
2827                  break;
2828                case 0x0d:
2829                    GETBYTE ();
2830                    switch (op[3] & 0x00)
2831                    {
2832                      case 0x00:
2833                        goto op_semantics_15;
2834                        break;
2835                    }
2836                  break;
2837                case 0x10:
2838                    GETBYTE ();
2839                    switch (op[3] & 0x00)
2840                    {
2841                      case 0x00:
2842                        goto op_semantics_16;
2843                        break;
2844                    }
2845                  break;
2846                case 0x11:
2847                    GETBYTE ();
2848                    switch (op[3] & 0x00)
2849                    {
2850                      case 0x00:
2851                        goto op_semantics_17;
2852                        break;
2853                    }
2854                  break;
2855                case 0x15:
2856                    GETBYTE ();
2857                    switch (op[3] & 0x00)
2858                    {
2859                      case 0x00:
2860                        goto op_semantics_18;
2861                        break;
2862                    }
2863                  break;
2864                default: UNSUPPORTED(); break;
2865              }
2866            break;
2867          case 0xa3:
2868              GETBYTE ();
2869              switch (op[2] & 0xff)
2870              {
2871                case 0x00:
2872                    GETBYTE ();
2873                    switch (op[3] & 0x00)
2874                    {
2875                      case 0x00:
2876                        goto op_semantics_7;
2877                        break;
2878                    }
2879                  break;
2880                case 0x02:
2881                    GETBYTE ();
2882                    switch (op[3] & 0x00)
2883                    {
2884                      case 0x00:
2885                        goto op_semantics_19;
2886                        break;
2887                    }
2888                  break;
2889                case 0x04:
2890                    GETBYTE ();
2891                    switch (op[3] & 0x00)
2892                    {
2893                      case 0x00:
2894                        goto op_semantics_8;
2895                        break;
2896                    }
2897                  break;
2898                case 0x05:
2899                    GETBYTE ();
2900                    switch (op[3] & 0x00)
2901                    {
2902                      case 0x00:
2903                        goto op_semantics_9;
2904                        break;
2905                    }
2906                  break;
2907                case 0x06:
2908                    GETBYTE ();
2909                    switch (op[3] & 0x00)
2910                    {
2911                      case 0x00:
2912                        goto op_semantics_10;
2913                        break;
2914                    }
2915                  break;
2916                case 0x07:
2917                    GETBYTE ();
2918                    switch (op[3] & 0x00)
2919                    {
2920                      case 0x00:
2921                        goto op_semantics_11;
2922                        break;
2923                    }
2924                  break;
2925                case 0x08:
2926                    GETBYTE ();
2927                    switch (op[3] & 0x00)
2928                    {
2929                      case 0x00:
2930                        goto op_semantics_12;
2931                        break;
2932                    }
2933                  break;
2934                case 0x09:
2935                    GETBYTE ();
2936                    switch (op[3] & 0x00)
2937                    {
2938                      case 0x00:
2939                        goto op_semantics_13;
2940                        break;
2941                    }
2942                  break;
2943                case 0x0c:
2944                    GETBYTE ();
2945                    switch (op[3] & 0x00)
2946                    {
2947                      case 0x00:
2948                        goto op_semantics_14;
2949                        break;
2950                    }
2951                  break;
2952                case 0x0d:
2953                    GETBYTE ();
2954                    switch (op[3] & 0x00)
2955                    {
2956                      case 0x00:
2957                        goto op_semantics_15;
2958                        break;
2959                    }
2960                  break;
2961                case 0x10:
2962                    GETBYTE ();
2963                    switch (op[3] & 0x00)
2964                    {
2965                      case 0x00:
2966                        goto op_semantics_16;
2967                        break;
2968                    }
2969                  break;
2970                case 0x11:
2971                    GETBYTE ();
2972                    switch (op[3] & 0x00)
2973                    {
2974                      case 0x00:
2975                        goto op_semantics_17;
2976                        break;
2977                    }
2978                  break;
2979                case 0x15:
2980                    GETBYTE ();
2981                    switch (op[3] & 0x00)
2982                    {
2983                      case 0x00:
2984                        goto op_semantics_18;
2985                        break;
2986                    }
2987                  break;
2988                default: UNSUPPORTED(); break;
2989              }
2990            break;
2991          case 0xc0:
2992              GETBYTE ();
2993              switch (op[2] & 0x00)
2994              {
2995                case 0x00:
2996                  goto op_semantics_1;
2997                  break;
2998              }
2999            break;
3000          case 0xc1:
3001              GETBYTE ();
3002              switch (op[2] & 0x00)
3003              {
3004                case 0x00:
3005                  goto op_semantics_1;
3006                  break;
3007              }
3008            break;
3009          case 0xc2:
3010              GETBYTE ();
3011              switch (op[2] & 0x00)
3012              {
3013                case 0x00:
3014                  goto op_semantics_1;
3015                  break;
3016              }
3017            break;
3018          case 0xc3:
3019              GETBYTE ();
3020              switch (op[2] & 0x00)
3021              {
3022                case 0x00:
3023                  goto op_semantics_1;
3024                  break;
3025              }
3026            break;
3027          case 0xc4:
3028              GETBYTE ();
3029              switch (op[2] & 0x00)
3030              {
3031                case 0x00:
3032                  goto op_semantics_2;
3033                  break;
3034              }
3035            break;
3036          case 0xc5:
3037              GETBYTE ();
3038              switch (op[2] & 0x00)
3039              {
3040                case 0x00:
3041                  goto op_semantics_2;
3042                  break;
3043              }
3044            break;
3045          case 0xc6:
3046              GETBYTE ();
3047              switch (op[2] & 0x00)
3048              {
3049                case 0x00:
3050                  goto op_semantics_2;
3051                  break;
3052              }
3053            break;
3054          case 0xc7:
3055              GETBYTE ();
3056              switch (op[2] & 0x00)
3057              {
3058                case 0x00:
3059                  goto op_semantics_2;
3060                  break;
3061              }
3062            break;
3063          case 0xc8:
3064              GETBYTE ();
3065              switch (op[2] & 0x00)
3066              {
3067                case 0x00:
3068                  goto op_semantics_3;
3069                  break;
3070              }
3071            break;
3072          case 0xc9:
3073              GETBYTE ();
3074              switch (op[2] & 0x00)
3075              {
3076                case 0x00:
3077                  goto op_semantics_3;
3078                  break;
3079              }
3080            break;
3081          case 0xca:
3082              GETBYTE ();
3083              switch (op[2] & 0x00)
3084              {
3085                case 0x00:
3086                  goto op_semantics_3;
3087                  break;
3088              }
3089            break;
3090          case 0xcb:
3091              GETBYTE ();
3092              switch (op[2] & 0x00)
3093              {
3094                case 0x00:
3095                  goto op_semantics_3;
3096                  break;
3097              }
3098            break;
3099          case 0xcc:
3100              GETBYTE ();
3101              switch (op[2] & 0x00)
3102              {
3103                case 0x00:
3104                  goto op_semantics_4;
3105                  break;
3106              }
3107            break;
3108          case 0xcd:
3109              GETBYTE ();
3110              switch (op[2] & 0x00)
3111              {
3112                case 0x00:
3113                  goto op_semantics_4;
3114                  break;
3115              }
3116            break;
3117          case 0xce:
3118              GETBYTE ();
3119              switch (op[2] & 0x00)
3120              {
3121                case 0x00:
3122                  goto op_semantics_4;
3123                  break;
3124              }
3125            break;
3126          case 0xcf:
3127              GETBYTE ();
3128              switch (op[2] & 0x00)
3129              {
3130                case 0x00:
3131                  goto op_semantics_4;
3132                  break;
3133              }
3134            break;
3135          case 0xd0:
3136              GETBYTE ();
3137              switch (op[2] & 0x00)
3138              {
3139                case 0x00:
3140                  goto op_semantics_5;
3141                  break;
3142              }
3143            break;
3144          case 0xd1:
3145              GETBYTE ();
3146              switch (op[2] & 0x00)
3147              {
3148                case 0x00:
3149                  goto op_semantics_5;
3150                  break;
3151              }
3152            break;
3153          case 0xd2:
3154              GETBYTE ();
3155              switch (op[2] & 0x00)
3156              {
3157                case 0x00:
3158                  goto op_semantics_5;
3159                  break;
3160              }
3161            break;
3162          case 0xd3:
3163              GETBYTE ();
3164              switch (op[2] & 0x00)
3165              {
3166                case 0x00:
3167                  goto op_semantics_5;
3168                  break;
3169              }
3170            break;
3171          case 0xd4:
3172              GETBYTE ();
3173              switch (op[2] & 0x00)
3174              {
3175                case 0x00:
3176                  goto op_semantics_6;
3177                  break;
3178              }
3179            break;
3180          case 0xd5:
3181              GETBYTE ();
3182              switch (op[2] & 0x00)
3183              {
3184                case 0x00:
3185                  goto op_semantics_6;
3186                  break;
3187              }
3188            break;
3189          case 0xd6:
3190              GETBYTE ();
3191              switch (op[2] & 0x00)
3192              {
3193                case 0x00:
3194                  goto op_semantics_6;
3195                  break;
3196              }
3197            break;
3198          case 0xd7:
3199              GETBYTE ();
3200              switch (op[2] & 0x00)
3201              {
3202                case 0x00:
3203                  goto op_semantics_6;
3204                  break;
3205              }
3206            break;
3207          case 0xe0:
3208              GETBYTE ();
3209              switch (op[2] & 0xff)
3210              {
3211                case 0x00:
3212                    GETBYTE ();
3213                    switch (op[3] & 0x00)
3214                    {
3215                      case 0x00:
3216                        goto op_semantics_7;
3217                        break;
3218                    }
3219                  break;
3220                case 0x04:
3221                    GETBYTE ();
3222                    switch (op[3] & 0x00)
3223                    {
3224                      case 0x00:
3225                        goto op_semantics_8;
3226                        break;
3227                    }
3228                  break;
3229                case 0x05:
3230                    GETBYTE ();
3231                    switch (op[3] & 0x00)
3232                    {
3233                      case 0x00:
3234                        goto op_semantics_9;
3235                        break;
3236                    }
3237                  break;
3238                case 0x06:
3239                    GETBYTE ();
3240                    switch (op[3] & 0x00)
3241                    {
3242                      case 0x00:
3243                        goto op_semantics_10;
3244                        break;
3245                    }
3246                  break;
3247                case 0x07:
3248                    GETBYTE ();
3249                    switch (op[3] & 0x00)
3250                    {
3251                      case 0x00:
3252                        goto op_semantics_11;
3253                        break;
3254                    }
3255                  break;
3256                case 0x08:
3257                    GETBYTE ();
3258                    switch (op[3] & 0x00)
3259                    {
3260                      case 0x00:
3261                        goto op_semantics_12;
3262                        break;
3263                    }
3264                  break;
3265                case 0x09:
3266                    GETBYTE ();
3267                    switch (op[3] & 0x00)
3268                    {
3269                      case 0x00:
3270                        goto op_semantics_13;
3271                        break;
3272                    }
3273                  break;
3274                case 0x0c:
3275                    GETBYTE ();
3276                    switch (op[3] & 0x00)
3277                    {
3278                      case 0x00:
3279                        goto op_semantics_14;
3280                        break;
3281                    }
3282                  break;
3283                case 0x0d:
3284                    GETBYTE ();
3285                    switch (op[3] & 0x00)
3286                    {
3287                      case 0x00:
3288                        goto op_semantics_15;
3289                        break;
3290                    }
3291                  break;
3292                case 0x10:
3293                    GETBYTE ();
3294                    switch (op[3] & 0x00)
3295                    {
3296                      case 0x00:
3297                        goto op_semantics_16;
3298                        break;
3299                    }
3300                  break;
3301                case 0x11:
3302                    GETBYTE ();
3303                    switch (op[3] & 0x00)
3304                    {
3305                      case 0x00:
3306                        goto op_semantics_17;
3307                        break;
3308                    }
3309                  break;
3310                case 0x15:
3311                    GETBYTE ();
3312                    switch (op[3] & 0x00)
3313                    {
3314                      case 0x00:
3315                        goto op_semantics_18;
3316                        break;
3317                    }
3318                  break;
3319                default: UNSUPPORTED(); break;
3320              }
3321            break;
3322          case 0xe1:
3323              GETBYTE ();
3324              switch (op[2] & 0xff)
3325              {
3326                case 0x00:
3327                    GETBYTE ();
3328                    switch (op[3] & 0x00)
3329                    {
3330                      case 0x00:
3331                        goto op_semantics_7;
3332                        break;
3333                    }
3334                  break;
3335                case 0x04:
3336                    GETBYTE ();
3337                    switch (op[3] & 0x00)
3338                    {
3339                      case 0x00:
3340                        goto op_semantics_8;
3341                        break;
3342                    }
3343                  break;
3344                case 0x05:
3345                    GETBYTE ();
3346                    switch (op[3] & 0x00)
3347                    {
3348                      case 0x00:
3349                        goto op_semantics_9;
3350                        break;
3351                    }
3352                  break;
3353                case 0x06:
3354                    GETBYTE ();
3355                    switch (op[3] & 0x00)
3356                    {
3357                      case 0x00:
3358                        goto op_semantics_10;
3359                        break;
3360                    }
3361                  break;
3362                case 0x07:
3363                    GETBYTE ();
3364                    switch (op[3] & 0x00)
3365                    {
3366                      case 0x00:
3367                        goto op_semantics_11;
3368                        break;
3369                    }
3370                  break;
3371                case 0x08:
3372                    GETBYTE ();
3373                    switch (op[3] & 0x00)
3374                    {
3375                      case 0x00:
3376                        goto op_semantics_12;
3377                        break;
3378                    }
3379                  break;
3380                case 0x09:
3381                    GETBYTE ();
3382                    switch (op[3] & 0x00)
3383                    {
3384                      case 0x00:
3385                        goto op_semantics_13;
3386                        break;
3387                    }
3388                  break;
3389                case 0x0c:
3390                    GETBYTE ();
3391                    switch (op[3] & 0x00)
3392                    {
3393                      case 0x00:
3394                        goto op_semantics_14;
3395                        break;
3396                    }
3397                  break;
3398                case 0x0d:
3399                    GETBYTE ();
3400                    switch (op[3] & 0x00)
3401                    {
3402                      case 0x00:
3403                        goto op_semantics_15;
3404                        break;
3405                    }
3406                  break;
3407                case 0x10:
3408                    GETBYTE ();
3409                    switch (op[3] & 0x00)
3410                    {
3411                      case 0x00:
3412                        goto op_semantics_16;
3413                        break;
3414                    }
3415                  break;
3416                case 0x11:
3417                    GETBYTE ();
3418                    switch (op[3] & 0x00)
3419                    {
3420                      case 0x00:
3421                        goto op_semantics_17;
3422                        break;
3423                    }
3424                  break;
3425                case 0x15:
3426                    GETBYTE ();
3427                    switch (op[3] & 0x00)
3428                    {
3429                      case 0x00:
3430                        goto op_semantics_18;
3431                        break;
3432                    }
3433                  break;
3434                default: UNSUPPORTED(); break;
3435              }
3436            break;
3437          case 0xe2:
3438              GETBYTE ();
3439              switch (op[2] & 0xff)
3440              {
3441                case 0x00:
3442                    GETBYTE ();
3443                    switch (op[3] & 0x00)
3444                    {
3445                      case 0x00:
3446                        goto op_semantics_7;
3447                        break;
3448                    }
3449                  break;
3450                case 0x04:
3451                    GETBYTE ();
3452                    switch (op[3] & 0x00)
3453                    {
3454                      case 0x00:
3455                        goto op_semantics_8;
3456                        break;
3457                    }
3458                  break;
3459                case 0x05:
3460                    GETBYTE ();
3461                    switch (op[3] & 0x00)
3462                    {
3463                      case 0x00:
3464                        goto op_semantics_9;
3465                        break;
3466                    }
3467                  break;
3468                case 0x06:
3469                    GETBYTE ();
3470                    switch (op[3] & 0x00)
3471                    {
3472                      case 0x00:
3473                        goto op_semantics_10;
3474                        break;
3475                    }
3476                  break;
3477                case 0x07:
3478                    GETBYTE ();
3479                    switch (op[3] & 0x00)
3480                    {
3481                      case 0x00:
3482                        goto op_semantics_11;
3483                        break;
3484                    }
3485                  break;
3486                case 0x08:
3487                    GETBYTE ();
3488                    switch (op[3] & 0x00)
3489                    {
3490                      case 0x00:
3491                        goto op_semantics_12;
3492                        break;
3493                    }
3494                  break;
3495                case 0x09:
3496                    GETBYTE ();
3497                    switch (op[3] & 0x00)
3498                    {
3499                      case 0x00:
3500                        goto op_semantics_13;
3501                        break;
3502                    }
3503                  break;
3504                case 0x0c:
3505                    GETBYTE ();
3506                    switch (op[3] & 0x00)
3507                    {
3508                      case 0x00:
3509                        goto op_semantics_14;
3510                        break;
3511                    }
3512                  break;
3513                case 0x0d:
3514                    GETBYTE ();
3515                    switch (op[3] & 0x00)
3516                    {
3517                      case 0x00:
3518                        goto op_semantics_15;
3519                        break;
3520                    }
3521                  break;
3522                case 0x10:
3523                    GETBYTE ();
3524                    switch (op[3] & 0x00)
3525                    {
3526                      case 0x00:
3527                        goto op_semantics_16;
3528                        break;
3529                    }
3530                  break;
3531                case 0x11:
3532                    GETBYTE ();
3533                    switch (op[3] & 0x00)
3534                    {
3535                      case 0x00:
3536                        goto op_semantics_17;
3537                        break;
3538                    }
3539                  break;
3540                case 0x15:
3541                    GETBYTE ();
3542                    switch (op[3] & 0x00)
3543                    {
3544                      case 0x00:
3545                        goto op_semantics_18;
3546                        break;
3547                    }
3548                  break;
3549                default: UNSUPPORTED(); break;
3550              }
3551            break;
3552          case 0xe3:
3553              GETBYTE ();
3554              switch (op[2] & 0xff)
3555              {
3556                case 0x00:
3557                    GETBYTE ();
3558                    switch (op[3] & 0x00)
3559                    {
3560                      case 0x00:
3561                        goto op_semantics_7;
3562                        break;
3563                    }
3564                  break;
3565                case 0x04:
3566                    GETBYTE ();
3567                    switch (op[3] & 0x00)
3568                    {
3569                      case 0x00:
3570                        goto op_semantics_8;
3571                        break;
3572                    }
3573                  break;
3574                case 0x05:
3575                    GETBYTE ();
3576                    switch (op[3] & 0x00)
3577                    {
3578                      case 0x00:
3579                        goto op_semantics_9;
3580                        break;
3581                    }
3582                  break;
3583                case 0x06:
3584                    GETBYTE ();
3585                    switch (op[3] & 0x00)
3586                    {
3587                      case 0x00:
3588                        goto op_semantics_10;
3589                        break;
3590                    }
3591                  break;
3592                case 0x07:
3593                    GETBYTE ();
3594                    switch (op[3] & 0x00)
3595                    {
3596                      case 0x00:
3597                        goto op_semantics_11;
3598                        break;
3599                    }
3600                  break;
3601                case 0x08:
3602                    GETBYTE ();
3603                    switch (op[3] & 0x00)
3604                    {
3605                      case 0x00:
3606                        goto op_semantics_12;
3607                        break;
3608                    }
3609                  break;
3610                case 0x09:
3611                    GETBYTE ();
3612                    switch (op[3] & 0x00)
3613                    {
3614                      case 0x00:
3615                        goto op_semantics_13;
3616                        break;
3617                    }
3618                  break;
3619                case 0x0c:
3620                    GETBYTE ();
3621                    switch (op[3] & 0x00)
3622                    {
3623                      case 0x00:
3624                        goto op_semantics_14;
3625                        break;
3626                    }
3627                  break;
3628                case 0x0d:
3629                    GETBYTE ();
3630                    switch (op[3] & 0x00)
3631                    {
3632                      case 0x00:
3633                        goto op_semantics_15;
3634                        break;
3635                    }
3636                  break;
3637                case 0x10:
3638                    GETBYTE ();
3639                    switch (op[3] & 0x00)
3640                    {
3641                      case 0x00:
3642                        goto op_semantics_16;
3643                        break;
3644                    }
3645                  break;
3646                case 0x11:
3647                    GETBYTE ();
3648                    switch (op[3] & 0x00)
3649                    {
3650                      case 0x00:
3651                        goto op_semantics_17;
3652                        break;
3653                    }
3654                  break;
3655                case 0x15:
3656                    GETBYTE ();
3657                    switch (op[3] & 0x00)
3658                    {
3659                      case 0x00:
3660                        goto op_semantics_18;
3661                        break;
3662                    }
3663                  break;
3664                default: UNSUPPORTED(); break;
3665              }
3666            break;
3667          default: UNSUPPORTED(); break;
3668        }
3669      break;
3670    case 0x08:
3671    case 0x09:
3672    case 0x0a:
3673    case 0x0b:
3674    case 0x0c:
3675    case 0x0d:
3676    case 0x0e:
3677    case 0x0f:
3678        {
3679          /** 0000 1dsp			bra.s	%a0 */
3680#line 800 "rx-decode.opc"
3681          int dsp AU = op[0] & 0x07;
3682          if (trace)
3683            {
3684              printf ("\033[33m%s\033[0m  %02x\n",
3685                     "/** 0000 1dsp			bra.s	%a0 */",
3686                     op[0]);
3687              printf ("  dsp = 0x%x\n", dsp);
3688            }
3689          SYNTAX("bra.s	%a0");
3690#line 800 "rx-decode.opc"
3691          ID(branch); DC(pc + dsp3map[dsp]);
3692
3693        }
3694      break;
3695    case 0x10:
3696    case 0x11:
3697    case 0x12:
3698    case 0x13:
3699    case 0x14:
3700    case 0x15:
3701    case 0x16:
3702    case 0x17:
3703    case 0x18:
3704    case 0x19:
3705    case 0x1a:
3706    case 0x1b:
3707    case 0x1c:
3708    case 0x1d:
3709    case 0x1e:
3710    case 0x1f:
3711        {
3712          /** 0001 n dsp			b%1.s	%a0 */
3713#line 790 "rx-decode.opc"
3714          int n AU = (op[0] >> 3) & 0x01;
3715#line 790 "rx-decode.opc"
3716          int dsp AU = op[0] & 0x07;
3717          if (trace)
3718            {
3719              printf ("\033[33m%s\033[0m  %02x\n",
3720                     "/** 0001 n dsp			b%1.s	%a0 */",
3721                     op[0]);
3722              printf ("  n = 0x%x,", n);
3723              printf ("  dsp = 0x%x\n", dsp);
3724            }
3725          SYNTAX("b%1.s	%a0");
3726#line 790 "rx-decode.opc"
3727          ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3728
3729        }
3730      break;
3731    case 0x20:
3732    case 0x21:
3733    case 0x22:
3734    case 0x23:
3735    case 0x24:
3736    case 0x25:
3737    case 0x26:
3738    case 0x27:
3739    case 0x28:
3740    case 0x29:
3741    case 0x2a:
3742    case 0x2b:
3743    case 0x2c:
3744    case 0x2d:
3745    case 0x2f:
3746        {
3747          /** 0010 cond			b%1.b	%a0 */
3748#line 793 "rx-decode.opc"
3749          int cond AU = op[0] & 0x0f;
3750          if (trace)
3751            {
3752              printf ("\033[33m%s\033[0m  %02x\n",
3753                     "/** 0010 cond			b%1.b	%a0 */",
3754                     op[0]);
3755              printf ("  cond = 0x%x\n", cond);
3756            }
3757          SYNTAX("b%1.b	%a0");
3758#line 793 "rx-decode.opc"
3759          ID(branch); Scc(cond); DC(pc + IMMex (1));
3760
3761        }
3762      break;
3763    case 0x2e:
3764        {
3765          /** 0010 1110			bra.b	%a0 */
3766          if (trace)
3767            {
3768              printf ("\033[33m%s\033[0m  %02x\n",
3769                     "/** 0010 1110			bra.b	%a0 */",
3770                     op[0]);
3771            }
3772          SYNTAX("bra.b	%a0");
3773#line 803 "rx-decode.opc"
3774          ID(branch); DC(pc + IMMex(1));
3775
3776        }
3777      break;
3778    case 0x38:
3779        {
3780          /** 0011 1000			bra.w	%a0 */
3781          if (trace)
3782            {
3783              printf ("\033[33m%s\033[0m  %02x\n",
3784                     "/** 0011 1000			bra.w	%a0 */",
3785                     op[0]);
3786            }
3787          SYNTAX("bra.w	%a0");
3788#line 806 "rx-decode.opc"
3789          ID(branch); DC(pc + IMMex(2));
3790
3791        }
3792      break;
3793    case 0x39:
3794        {
3795          /** 0011 1001			bsr.w	%a0 */
3796          if (trace)
3797            {
3798              printf ("\033[33m%s\033[0m  %02x\n",
3799                     "/** 0011 1001			bsr.w	%a0 */",
3800                     op[0]);
3801            }
3802          SYNTAX("bsr.w	%a0");
3803#line 822 "rx-decode.opc"
3804          ID(jsr); DC(pc + IMMex(2));
3805
3806        }
3807      break;
3808    case 0x3a:
3809    case 0x3b:
3810        {
3811          /** 0011 101c			b%1.w	%a0 */
3812#line 796 "rx-decode.opc"
3813          int c AU = op[0] & 0x01;
3814          if (trace)
3815            {
3816              printf ("\033[33m%s\033[0m  %02x\n",
3817                     "/** 0011 101c			b%1.w	%a0 */",
3818                     op[0]);
3819              printf ("  c = 0x%x\n", c);
3820            }
3821          SYNTAX("b%1.w	%a0");
3822#line 796 "rx-decode.opc"
3823          ID(branch); Scc(c); DC(pc + IMMex (2));
3824
3825
3826        }
3827      break;
3828    case 0x3c:
3829        GETBYTE ();
3830        switch (op[1] & 0x00)
3831        {
3832          case 0x00:
3833            op_semantics_20:
3834              {
3835                /** 0011 11sz d dst sppp		mov%s	#%1, %0 */
3836#line 332 "rx-decode.opc"
3837                int sz AU = op[0] & 0x03;
3838#line 332 "rx-decode.opc"
3839                int d AU = (op[1] >> 7) & 0x01;
3840#line 332 "rx-decode.opc"
3841                int dst AU = (op[1] >> 4) & 0x07;
3842#line 332 "rx-decode.opc"
3843                int sppp AU = op[1] & 0x0f;
3844                if (trace)
3845                  {
3846                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3847                           "/** 0011 11sz d dst sppp		mov%s	#%1, %0 */",
3848                           op[0], op[1]);
3849                    printf ("  sz = 0x%x,", sz);
3850                    printf ("  d = 0x%x,", d);
3851                    printf ("  dst = 0x%x,", dst);
3852                    printf ("  sppp = 0x%x\n", sppp);
3853                  }
3854                SYNTAX("mov%s	#%1, %0");
3855#line 332 "rx-decode.opc"
3856                ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3857
3858              }
3859            break;
3860        }
3861      break;
3862    case 0x3d:
3863        GETBYTE ();
3864        switch (op[1] & 0x00)
3865        {
3866          case 0x00:
3867            goto op_semantics_20;
3868            break;
3869        }
3870      break;
3871    case 0x3e:
3872        GETBYTE ();
3873        switch (op[1] & 0x00)
3874        {
3875          case 0x00:
3876            goto op_semantics_20;
3877            break;
3878        }
3879      break;
3880    case 0x3f:
3881        GETBYTE ();
3882        switch (op[1] & 0x00)
3883        {
3884          case 0x00:
3885              {
3886                /** 0011 1111 rega regb		rtsd	#%1, %2-%0 */
3887#line 429 "rx-decode.opc"
3888                int rega AU = (op[1] >> 4) & 0x0f;
3889#line 429 "rx-decode.opc"
3890                int regb AU = op[1] & 0x0f;
3891                if (trace)
3892                  {
3893                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3894                           "/** 0011 1111 rega regb		rtsd	#%1, %2-%0 */",
3895                           op[0], op[1]);
3896                    printf ("  rega = 0x%x,", rega);
3897                    printf ("  regb = 0x%x\n", regb);
3898                  }
3899                SYNTAX("rtsd	#%1, %2-%0");
3900#line 429 "rx-decode.opc"
3901                ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3902
3903              /*----------------------------------------------------------------------*/
3904              /* AND									*/
3905
3906              }
3907            break;
3908        }
3909      break;
3910    case 0x40:
3911        GETBYTE ();
3912        switch (op[1] & 0x00)
3913        {
3914          case 0x00:
3915            op_semantics_21:
3916              {
3917                /** 0100 00ss rsrc rdst			sub	%2%S2, %1 */
3918#line 564 "rx-decode.opc"
3919                int ss AU = op[0] & 0x03;
3920#line 564 "rx-decode.opc"
3921                int rsrc AU = (op[1] >> 4) & 0x0f;
3922#line 564 "rx-decode.opc"
3923                int rdst AU = op[1] & 0x0f;
3924                if (trace)
3925                  {
3926                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3927                           "/** 0100 00ss rsrc rdst			sub	%2%S2, %1 */",
3928                           op[0], op[1]);
3929                    printf ("  ss = 0x%x,", ss);
3930                    printf ("  rsrc = 0x%x,", rsrc);
3931                    printf ("  rdst = 0x%x\n", rdst);
3932                  }
3933                SYNTAX("sub	%2%S2, %1");
3934#line 564 "rx-decode.opc"
3935                ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3936
3937              }
3938            break;
3939        }
3940      break;
3941    case 0x41:
3942        GETBYTE ();
3943        switch (op[1] & 0x00)
3944        {
3945          case 0x00:
3946            goto op_semantics_21;
3947            break;
3948        }
3949      break;
3950    case 0x42:
3951        GETBYTE ();
3952        switch (op[1] & 0x00)
3953        {
3954          case 0x00:
3955            goto op_semantics_21;
3956            break;
3957        }
3958      break;
3959    case 0x43:
3960        GETBYTE ();
3961        switch (op[1] & 0x00)
3962        {
3963          case 0x00:
3964            goto op_semantics_21;
3965            break;
3966        }
3967      break;
3968    case 0x44:
3969        GETBYTE ();
3970        switch (op[1] & 0x00)
3971        {
3972          case 0x00:
3973            op_semantics_22:
3974              {
3975                /** 0100 01ss rsrc rdst		cmp	%2%S2, %1 */
3976#line 552 "rx-decode.opc"
3977                int ss AU = op[0] & 0x03;
3978#line 552 "rx-decode.opc"
3979                int rsrc AU = (op[1] >> 4) & 0x0f;
3980#line 552 "rx-decode.opc"
3981                int rdst AU = op[1] & 0x0f;
3982                if (trace)
3983                  {
3984                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3985                           "/** 0100 01ss rsrc rdst		cmp	%2%S2, %1 */",
3986                           op[0], op[1]);
3987                    printf ("  ss = 0x%x,", ss);
3988                    printf ("  rsrc = 0x%x,", rsrc);
3989                    printf ("  rdst = 0x%x\n", rdst);
3990                  }
3991                SYNTAX("cmp	%2%S2, %1");
3992#line 552 "rx-decode.opc"
3993                ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3994
3995              }
3996            break;
3997        }
3998      break;
3999    case 0x45:
4000        GETBYTE ();
4001        switch (op[1] & 0x00)
4002        {
4003          case 0x00:
4004            goto op_semantics_22;
4005            break;
4006        }
4007      break;
4008    case 0x46:
4009        GETBYTE ();
4010        switch (op[1] & 0x00)
4011        {
4012          case 0x00:
4013            goto op_semantics_22;
4014            break;
4015        }
4016      break;
4017    case 0x47:
4018        GETBYTE ();
4019        switch (op[1] & 0x00)
4020        {
4021          case 0x00:
4022            goto op_semantics_22;
4023            break;
4024        }
4025      break;
4026    case 0x48:
4027        GETBYTE ();
4028        switch (op[1] & 0x00)
4029        {
4030          case 0x00:
4031            op_semantics_23:
4032              {
4033                /** 0100 10ss rsrc rdst			add	%1%S1, %0 */
4034#line 528 "rx-decode.opc"
4035                int ss AU = op[0] & 0x03;
4036#line 528 "rx-decode.opc"
4037                int rsrc AU = (op[1] >> 4) & 0x0f;
4038#line 528 "rx-decode.opc"
4039                int rdst AU = op[1] & 0x0f;
4040                if (trace)
4041                  {
4042                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4043                           "/** 0100 10ss rsrc rdst			add	%1%S1, %0 */",
4044                           op[0], op[1]);
4045                    printf ("  ss = 0x%x,", ss);
4046                    printf ("  rsrc = 0x%x,", rsrc);
4047                    printf ("  rdst = 0x%x\n", rdst);
4048                  }
4049                SYNTAX("add	%1%S1, %0");
4050#line 528 "rx-decode.opc"
4051                ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4052
4053              }
4054            break;
4055        }
4056      break;
4057    case 0x49:
4058        GETBYTE ();
4059        switch (op[1] & 0x00)
4060        {
4061          case 0x00:
4062            goto op_semantics_23;
4063            break;
4064        }
4065      break;
4066    case 0x4a:
4067        GETBYTE ();
4068        switch (op[1] & 0x00)
4069        {
4070          case 0x00:
4071            goto op_semantics_23;
4072            break;
4073        }
4074      break;
4075    case 0x4b:
4076        GETBYTE ();
4077        switch (op[1] & 0x00)
4078        {
4079          case 0x00:
4080            goto op_semantics_23;
4081            break;
4082        }
4083      break;
4084    case 0x4c:
4085        GETBYTE ();
4086        switch (op[1] & 0x00)
4087        {
4088          case 0x00:
4089            op_semantics_24:
4090              {
4091                /** 0100 11ss rsrc rdst			mul	%1%S1, %0 */
4092#line 671 "rx-decode.opc"
4093                int ss AU = op[0] & 0x03;
4094#line 671 "rx-decode.opc"
4095                int rsrc AU = (op[1] >> 4) & 0x0f;
4096#line 671 "rx-decode.opc"
4097                int rdst AU = op[1] & 0x0f;
4098                if (trace)
4099                  {
4100                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4101                           "/** 0100 11ss rsrc rdst			mul	%1%S1, %0 */",
4102                           op[0], op[1]);
4103                    printf ("  ss = 0x%x,", ss);
4104                    printf ("  rsrc = 0x%x,", rsrc);
4105                    printf ("  rdst = 0x%x\n", rdst);
4106                  }
4107                SYNTAX("mul	%1%S1, %0");
4108#line 671 "rx-decode.opc"
4109                ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4110
4111              }
4112            break;
4113        }
4114      break;
4115    case 0x4d:
4116        GETBYTE ();
4117        switch (op[1] & 0x00)
4118        {
4119          case 0x00:
4120            goto op_semantics_24;
4121            break;
4122        }
4123      break;
4124    case 0x4e:
4125        GETBYTE ();
4126        switch (op[1] & 0x00)
4127        {
4128          case 0x00:
4129            goto op_semantics_24;
4130            break;
4131        }
4132      break;
4133    case 0x4f:
4134        GETBYTE ();
4135        switch (op[1] & 0x00)
4136        {
4137          case 0x00:
4138            goto op_semantics_24;
4139            break;
4140        }
4141      break;
4142    case 0x50:
4143        GETBYTE ();
4144        switch (op[1] & 0x00)
4145        {
4146          case 0x00:
4147            op_semantics_25:
4148              {
4149                /** 0101 00ss rsrc rdst			and	%1%S1, %0 */
4150#line 441 "rx-decode.opc"
4151                int ss AU = op[0] & 0x03;
4152#line 441 "rx-decode.opc"
4153                int rsrc AU = (op[1] >> 4) & 0x0f;
4154#line 441 "rx-decode.opc"
4155                int rdst AU = op[1] & 0x0f;
4156                if (trace)
4157                  {
4158                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4159                           "/** 0101 00ss rsrc rdst			and	%1%S1, %0 */",
4160                           op[0], op[1]);
4161                    printf ("  ss = 0x%x,", ss);
4162                    printf ("  rsrc = 0x%x,", rsrc);
4163                    printf ("  rdst = 0x%x\n", rdst);
4164                  }
4165                SYNTAX("and	%1%S1, %0");
4166#line 441 "rx-decode.opc"
4167                ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4168
4169              }
4170            break;
4171        }
4172      break;
4173    case 0x51:
4174        GETBYTE ();
4175        switch (op[1] & 0x00)
4176        {
4177          case 0x00:
4178            goto op_semantics_25;
4179            break;
4180        }
4181      break;
4182    case 0x52:
4183        GETBYTE ();
4184        switch (op[1] & 0x00)
4185        {
4186          case 0x00:
4187            goto op_semantics_25;
4188            break;
4189        }
4190      break;
4191    case 0x53:
4192        GETBYTE ();
4193        switch (op[1] & 0x00)
4194        {
4195          case 0x00:
4196            goto op_semantics_25;
4197            break;
4198        }
4199      break;
4200    case 0x54:
4201        GETBYTE ();
4202        switch (op[1] & 0x00)
4203        {
4204          case 0x00:
4205            op_semantics_26:
4206              {
4207                /** 0101 01ss rsrc rdst			or	%1%S1, %0 */
4208#line 459 "rx-decode.opc"
4209                int ss AU = op[0] & 0x03;
4210#line 459 "rx-decode.opc"
4211                int rsrc AU = (op[1] >> 4) & 0x0f;
4212#line 459 "rx-decode.opc"
4213                int rdst AU = op[1] & 0x0f;
4214                if (trace)
4215                  {
4216                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4217                           "/** 0101 01ss rsrc rdst			or	%1%S1, %0 */",
4218                           op[0], op[1]);
4219                    printf ("  ss = 0x%x,", ss);
4220                    printf ("  rsrc = 0x%x,", rsrc);
4221                    printf ("  rdst = 0x%x\n", rdst);
4222                  }
4223                SYNTAX("or	%1%S1, %0");
4224#line 459 "rx-decode.opc"
4225                ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4226
4227              }
4228            break;
4229        }
4230      break;
4231    case 0x55:
4232        GETBYTE ();
4233        switch (op[1] & 0x00)
4234        {
4235          case 0x00:
4236            goto op_semantics_26;
4237            break;
4238        }
4239      break;
4240    case 0x56:
4241        GETBYTE ();
4242        switch (op[1] & 0x00)
4243        {
4244          case 0x00:
4245            goto op_semantics_26;
4246            break;
4247        }
4248      break;
4249    case 0x57:
4250        GETBYTE ();
4251        switch (op[1] & 0x00)
4252        {
4253          case 0x00:
4254            goto op_semantics_26;
4255            break;
4256        }
4257      break;
4258    case 0x58:
4259        GETBYTE ();
4260        switch (op[1] & 0x00)
4261        {
4262          case 0x00:
4263            op_semantics_27:
4264              {
4265                /** 0101 1 s ss rsrc rdst	movu%s	%1, %0 */
4266#line 380 "rx-decode.opc"
4267                int s AU = (op[0] >> 2) & 0x01;
4268#line 380 "rx-decode.opc"
4269                int ss AU = op[0] & 0x03;
4270#line 380 "rx-decode.opc"
4271                int rsrc AU = (op[1] >> 4) & 0x0f;
4272#line 380 "rx-decode.opc"
4273                int rdst AU = op[1] & 0x0f;
4274                if (trace)
4275                  {
4276                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4277                           "/** 0101 1 s ss rsrc rdst	movu%s	%1, %0 */",
4278                           op[0], op[1]);
4279                    printf ("  s = 0x%x,", s);
4280                    printf ("  ss = 0x%x,", ss);
4281                    printf ("  rsrc = 0x%x,", rsrc);
4282                    printf ("  rdst = 0x%x\n", rdst);
4283                  }
4284                SYNTAX("movu%s	%1, %0");
4285#line 380 "rx-decode.opc"
4286                ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4287
4288              }
4289            break;
4290        }
4291      break;
4292    case 0x59:
4293        GETBYTE ();
4294        switch (op[1] & 0x00)
4295        {
4296          case 0x00:
4297            goto op_semantics_27;
4298            break;
4299        }
4300      break;
4301    case 0x5a:
4302        GETBYTE ();
4303        switch (op[1] & 0x00)
4304        {
4305          case 0x00:
4306            goto op_semantics_27;
4307            break;
4308        }
4309      break;
4310    case 0x5b:
4311        GETBYTE ();
4312        switch (op[1] & 0x00)
4313        {
4314          case 0x00:
4315            goto op_semantics_27;
4316            break;
4317        }
4318      break;
4319    case 0x5c:
4320        GETBYTE ();
4321        switch (op[1] & 0x00)
4322        {
4323          case 0x00:
4324            goto op_semantics_27;
4325            break;
4326        }
4327      break;
4328    case 0x5d:
4329        GETBYTE ();
4330        switch (op[1] & 0x00)
4331        {
4332          case 0x00:
4333            goto op_semantics_27;
4334            break;
4335        }
4336      break;
4337    case 0x5e:
4338        GETBYTE ();
4339        switch (op[1] & 0x00)
4340        {
4341          case 0x00:
4342            goto op_semantics_27;
4343            break;
4344        }
4345      break;
4346    case 0x5f:
4347        GETBYTE ();
4348        switch (op[1] & 0x00)
4349        {
4350          case 0x00:
4351            goto op_semantics_27;
4352            break;
4353        }
4354      break;
4355    case 0x60:
4356        GETBYTE ();
4357        switch (op[1] & 0x00)
4358        {
4359          case 0x00:
4360              {
4361                /** 0110 0000 immm rdst			sub	#%2, %0 */
4362#line 561 "rx-decode.opc"
4363                int immm AU = (op[1] >> 4) & 0x0f;
4364#line 561 "rx-decode.opc"
4365                int rdst AU = op[1] & 0x0f;
4366                if (trace)
4367                  {
4368                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4369                           "/** 0110 0000 immm rdst			sub	#%2, %0 */",
4370                           op[0], op[1]);
4371                    printf ("  immm = 0x%x,", immm);
4372                    printf ("  rdst = 0x%x\n", rdst);
4373                  }
4374                SYNTAX("sub	#%2, %0");
4375#line 561 "rx-decode.opc"
4376                ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4377
4378              }
4379            break;
4380        }
4381      break;
4382    case 0x61:
4383        GETBYTE ();
4384        switch (op[1] & 0x00)
4385        {
4386          case 0x00:
4387              {
4388                /** 0110 0001 immm rdst			cmp	#%2, %1 */
4389#line 543 "rx-decode.opc"
4390                int immm AU = (op[1] >> 4) & 0x0f;
4391#line 543 "rx-decode.opc"
4392                int rdst AU = op[1] & 0x0f;
4393                if (trace)
4394                  {
4395                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4396                           "/** 0110 0001 immm rdst			cmp	#%2, %1 */",
4397                           op[0], op[1]);
4398                    printf ("  immm = 0x%x,", immm);
4399                    printf ("  rdst = 0x%x\n", rdst);
4400                  }
4401                SYNTAX("cmp	#%2, %1");
4402#line 543 "rx-decode.opc"
4403                ID(sub); S2C(immm); SR(rdst); F_OSZC;
4404
4405              }
4406            break;
4407        }
4408      break;
4409    case 0x62:
4410        GETBYTE ();
4411        switch (op[1] & 0x00)
4412        {
4413          case 0x00:
4414              {
4415                /** 0110 0010 immm rdst			add	#%1, %0 */
4416#line 525 "rx-decode.opc"
4417                int immm AU = (op[1] >> 4) & 0x0f;
4418#line 525 "rx-decode.opc"
4419                int rdst AU = op[1] & 0x0f;
4420                if (trace)
4421                  {
4422                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4423                           "/** 0110 0010 immm rdst			add	#%1, %0 */",
4424                           op[0], op[1]);
4425                    printf ("  immm = 0x%x,", immm);
4426                    printf ("  rdst = 0x%x\n", rdst);
4427                  }
4428                SYNTAX("add	#%1, %0");
4429#line 525 "rx-decode.opc"
4430                ID(add); SC(immm); DR(rdst); F_OSZC;
4431
4432              }
4433            break;
4434        }
4435      break;
4436    case 0x63:
4437        GETBYTE ();
4438        switch (op[1] & 0x00)
4439        {
4440          case 0x00:
4441              {
4442                /** 0110 0011 immm rdst			mul	#%1, %0 */
4443#line 637 "rx-decode.opc"
4444                int immm AU = (op[1] >> 4) & 0x0f;
4445#line 637 "rx-decode.opc"
4446                int rdst AU = op[1] & 0x0f;
4447                if (trace)
4448                  {
4449                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4450                           "/** 0110 0011 immm rdst			mul	#%1, %0 */",
4451                           op[0], op[1]);
4452                    printf ("  immm = 0x%x,", immm);
4453                    printf ("  rdst = 0x%x\n", rdst);
4454                  }
4455                SYNTAX("mul	#%1, %0");
4456#line 637 "rx-decode.opc"
4457                if (immm == 1 && rdst == 0)
4458                  {
4459                    ID(nop2);
4460                    SYNTAX ("nop\t; mul\t#1, r0");
4461                  }
4462                else
4463                  {
4464                    ID(mul);
4465                  }
4466                DR(rdst); SC(immm); F_____;
4467
4468              }
4469            break;
4470        }
4471      break;
4472    case 0x64:
4473        GETBYTE ();
4474        switch (op[1] & 0x00)
4475        {
4476          case 0x00:
4477              {
4478                /** 0110 0100 immm rdst			and	#%1, %0 */
4479#line 435 "rx-decode.opc"
4480                int immm AU = (op[1] >> 4) & 0x0f;
4481#line 435 "rx-decode.opc"
4482                int rdst AU = op[1] & 0x0f;
4483                if (trace)
4484                  {
4485                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4486                           "/** 0110 0100 immm rdst			and	#%1, %0 */",
4487                           op[0], op[1]);
4488                    printf ("  immm = 0x%x,", immm);
4489                    printf ("  rdst = 0x%x\n", rdst);
4490                  }
4491                SYNTAX("and	#%1, %0");
4492#line 435 "rx-decode.opc"
4493                ID(and); SC(immm); DR(rdst); F__SZ_;
4494
4495              }
4496            break;
4497        }
4498      break;
4499    case 0x65:
4500        GETBYTE ();
4501        switch (op[1] & 0x00)
4502        {
4503          case 0x00:
4504              {
4505                /** 0110 0101 immm rdst			or	#%1, %0 */
4506#line 453 "rx-decode.opc"
4507                int immm AU = (op[1] >> 4) & 0x0f;
4508#line 453 "rx-decode.opc"
4509                int rdst AU = op[1] & 0x0f;
4510                if (trace)
4511                  {
4512                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4513                           "/** 0110 0101 immm rdst			or	#%1, %0 */",
4514                           op[0], op[1]);
4515                    printf ("  immm = 0x%x,", immm);
4516                    printf ("  rdst = 0x%x\n", rdst);
4517                  }
4518                SYNTAX("or	#%1, %0");
4519#line 453 "rx-decode.opc"
4520                ID(or); SC(immm); DR(rdst); F__SZ_;
4521
4522              }
4523            break;
4524        }
4525      break;
4526    case 0x66:
4527        GETBYTE ();
4528        switch (op[1] & 0x00)
4529        {
4530          case 0x00:
4531              {
4532                /** 0110 0110 immm rdst		mov%s	#%1, %0 */
4533#line 329 "rx-decode.opc"
4534                int immm AU = (op[1] >> 4) & 0x0f;
4535#line 329 "rx-decode.opc"
4536                int rdst AU = op[1] & 0x0f;
4537                if (trace)
4538                  {
4539                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4540                           "/** 0110 0110 immm rdst		mov%s	#%1, %0 */",
4541                           op[0], op[1]);
4542                    printf ("  immm = 0x%x,", immm);
4543                    printf ("  rdst = 0x%x\n", rdst);
4544                  }
4545                SYNTAX("mov%s	#%1, %0");
4546#line 329 "rx-decode.opc"
4547                ID(mov); DR(rdst); SC(immm); F_____;
4548
4549              }
4550            break;
4551        }
4552      break;
4553    case 0x67:
4554        {
4555          /** 0110 0111			rtsd	#%1 */
4556          if (trace)
4557            {
4558              printf ("\033[33m%s\033[0m  %02x\n",
4559                     "/** 0110 0111			rtsd	#%1 */",
4560                     op[0]);
4561            }
4562          SYNTAX("rtsd	#%1");
4563#line 426 "rx-decode.opc"
4564          ID(rtsd); SC(IMM(1) * 4);
4565
4566        }
4567      break;
4568    case 0x68:
4569        GETBYTE ();
4570        switch (op[1] & 0x00)
4571        {
4572          case 0x00:
4573            op_semantics_28:
4574              {
4575                /** 0110 100i mmmm rdst			shlr	#%2, %0 */
4576#line 751 "rx-decode.opc"
4577                int i AU = op[0] & 0x01;
4578#line 751 "rx-decode.opc"
4579                int mmmm AU = (op[1] >> 4) & 0x0f;
4580#line 751 "rx-decode.opc"
4581                int rdst AU = op[1] & 0x0f;
4582                if (trace)
4583                  {
4584                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4585                           "/** 0110 100i mmmm rdst			shlr	#%2, %0 */",
4586                           op[0], op[1]);
4587                    printf ("  i = 0x%x,", i);
4588                    printf ("  mmmm = 0x%x,", mmmm);
4589                    printf ("  rdst = 0x%x\n", rdst);
4590                  }
4591                SYNTAX("shlr	#%2, %0");
4592#line 751 "rx-decode.opc"
4593                ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4594
4595              }
4596            break;
4597        }
4598      break;
4599    case 0x69:
4600        GETBYTE ();
4601        switch (op[1] & 0x00)
4602        {
4603          case 0x00:
4604            goto op_semantics_28;
4605            break;
4606        }
4607      break;
4608    case 0x6a:
4609        GETBYTE ();
4610        switch (op[1] & 0x00)
4611        {
4612          case 0x00:
4613            op_semantics_29:
4614              {
4615                /** 0110 101i mmmm rdst			shar	#%2, %0 */
4616#line 741 "rx-decode.opc"
4617                int i AU = op[0] & 0x01;
4618#line 741 "rx-decode.opc"
4619                int mmmm AU = (op[1] >> 4) & 0x0f;
4620#line 741 "rx-decode.opc"
4621                int rdst AU = op[1] & 0x0f;
4622                if (trace)
4623                  {
4624                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4625                           "/** 0110 101i mmmm rdst			shar	#%2, %0 */",
4626                           op[0], op[1]);
4627                    printf ("  i = 0x%x,", i);
4628                    printf ("  mmmm = 0x%x,", mmmm);
4629                    printf ("  rdst = 0x%x\n", rdst);
4630                  }
4631                SYNTAX("shar	#%2, %0");
4632#line 741 "rx-decode.opc"
4633                ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4634
4635              }
4636            break;
4637        }
4638      break;
4639    case 0x6b:
4640        GETBYTE ();
4641        switch (op[1] & 0x00)
4642        {
4643          case 0x00:
4644            goto op_semantics_29;
4645            break;
4646        }
4647      break;
4648    case 0x6c:
4649        GETBYTE ();
4650        switch (op[1] & 0x00)
4651        {
4652          case 0x00:
4653            op_semantics_30:
4654              {
4655                /** 0110 110i mmmm rdst			shll	#%2, %0 */
4656#line 731 "rx-decode.opc"
4657                int i AU = op[0] & 0x01;
4658#line 731 "rx-decode.opc"
4659                int mmmm AU = (op[1] >> 4) & 0x0f;
4660#line 731 "rx-decode.opc"
4661                int rdst AU = op[1] & 0x0f;
4662                if (trace)
4663                  {
4664                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4665                           "/** 0110 110i mmmm rdst			shll	#%2, %0 */",
4666                           op[0], op[1]);
4667                    printf ("  i = 0x%x,", i);
4668                    printf ("  mmmm = 0x%x,", mmmm);
4669                    printf ("  rdst = 0x%x\n", rdst);
4670                  }
4671                SYNTAX("shll	#%2, %0");
4672#line 731 "rx-decode.opc"
4673                ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4674
4675              }
4676            break;
4677        }
4678      break;
4679    case 0x6d:
4680        GETBYTE ();
4681        switch (op[1] & 0x00)
4682        {
4683          case 0x00:
4684            goto op_semantics_30;
4685            break;
4686        }
4687      break;
4688    case 0x6e:
4689        GETBYTE ();
4690        switch (op[1] & 0x00)
4691        {
4692          case 0x00:
4693              {
4694                /** 0110 1110 dsta dstb		pushm	%1-%2 */
4695#line 393 "rx-decode.opc"
4696                int dsta AU = (op[1] >> 4) & 0x0f;
4697#line 393 "rx-decode.opc"
4698                int dstb AU = op[1] & 0x0f;
4699                if (trace)
4700                  {
4701                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4702                           "/** 0110 1110 dsta dstb		pushm	%1-%2 */",
4703                           op[0], op[1]);
4704                    printf ("  dsta = 0x%x,", dsta);
4705                    printf ("  dstb = 0x%x\n", dstb);
4706                  }
4707                SYNTAX("pushm	%1-%2");
4708#line 393 "rx-decode.opc"
4709                ID(pushm); SR(dsta); S2R(dstb); F_____;
4710
4711              }
4712            break;
4713        }
4714      break;
4715    case 0x6f:
4716        GETBYTE ();
4717        switch (op[1] & 0x00)
4718        {
4719          case 0x00:
4720              {
4721                /** 0110 1111 dsta dstb		popm	%1-%2 */
4722#line 390 "rx-decode.opc"
4723                int dsta AU = (op[1] >> 4) & 0x0f;
4724#line 390 "rx-decode.opc"
4725                int dstb AU = op[1] & 0x0f;
4726                if (trace)
4727                  {
4728                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4729                           "/** 0110 1111 dsta dstb		popm	%1-%2 */",
4730                           op[0], op[1]);
4731                    printf ("  dsta = 0x%x,", dsta);
4732                    printf ("  dstb = 0x%x\n", dstb);
4733                  }
4734                SYNTAX("popm	%1-%2");
4735#line 390 "rx-decode.opc"
4736                ID(popm); SR(dsta); S2R(dstb); F_____;
4737
4738              }
4739            break;
4740        }
4741      break;
4742    case 0x70:
4743        GETBYTE ();
4744        switch (op[1] & 0x00)
4745        {
4746          case 0x00:
4747            op_semantics_31:
4748              {
4749                /** 0111 00im rsrc rdst			add	#%1, %2, %0 */
4750#line 534 "rx-decode.opc"
4751                int im AU = op[0] & 0x03;
4752#line 534 "rx-decode.opc"
4753                int rsrc AU = (op[1] >> 4) & 0x0f;
4754#line 534 "rx-decode.opc"
4755                int rdst AU = op[1] & 0x0f;
4756                if (trace)
4757                  {
4758                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4759                           "/** 0111 00im rsrc rdst			add	#%1, %2, %0 */",
4760                           op[0], op[1]);
4761                    printf ("  im = 0x%x,", im);
4762                    printf ("  rsrc = 0x%x,", rsrc);
4763                    printf ("  rdst = 0x%x\n", rdst);
4764                  }
4765                SYNTAX("add	#%1, %2, %0");
4766#line 534 "rx-decode.opc"
4767                ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4768
4769              }
4770            break;
4771        }
4772      break;
4773    case 0x71:
4774        GETBYTE ();
4775        switch (op[1] & 0x00)
4776        {
4777          case 0x00:
4778            goto op_semantics_31;
4779            break;
4780        }
4781      break;
4782    case 0x72:
4783        GETBYTE ();
4784        switch (op[1] & 0x00)
4785        {
4786          case 0x00:
4787            goto op_semantics_31;
4788            break;
4789        }
4790      break;
4791    case 0x73:
4792        GETBYTE ();
4793        switch (op[1] & 0x00)
4794        {
4795          case 0x00:
4796            goto op_semantics_31;
4797            break;
4798        }
4799      break;
4800    case 0x74:
4801        GETBYTE ();
4802        switch (op[1] & 0xf0)
4803        {
4804          case 0x00:
4805            op_semantics_32:
4806              {
4807                /** 0111 01im 0000 rsrc		cmp	#%2, %1%S1 */
4808#line 546 "rx-decode.opc"
4809                int im AU = op[0] & 0x03;
4810#line 546 "rx-decode.opc"
4811                int rsrc AU = op[1] & 0x0f;
4812                if (trace)
4813                  {
4814                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4815                           "/** 0111 01im 0000 rsrc		cmp	#%2, %1%S1 */",
4816                           op[0], op[1]);
4817                    printf ("  im = 0x%x,", im);
4818                    printf ("  rsrc = 0x%x\n", rsrc);
4819                  }
4820                SYNTAX("cmp	#%2, %1%S1");
4821#line 546 "rx-decode.opc"
4822                ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4823
4824              }
4825            break;
4826          case 0x10:
4827            op_semantics_33:
4828              {
4829                /** 0111 01im 0001rdst			mul	#%1, %0 */
4830#line 649 "rx-decode.opc"
4831                int im AU = op[0] & 0x03;
4832#line 649 "rx-decode.opc"
4833                int rdst AU = op[1] & 0x0f;
4834                if (trace)
4835                  {
4836                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4837                           "/** 0111 01im 0001rdst			mul	#%1, %0 */",
4838                           op[0], op[1]);
4839                    printf ("  im = 0x%x,", im);
4840                    printf ("  rdst = 0x%x\n", rdst);
4841                  }
4842                SYNTAX("mul	#%1, %0");
4843#line 649 "rx-decode.opc"
4844                int val = IMMex(im);
4845                if (val == 1 && rdst == 0)
4846                  {
4847                    SYNTAX("nop\t; mul\t#1, r0");
4848                    switch (im)
4849              	{
4850              	case 2: ID(nop4); break;
4851              	case 3: ID(nop5); break;
4852              	case 0: ID(nop6); break;
4853              	default:
4854              	  ID(mul);
4855              	  SYNTAX("mul	#%1, %0");
4856              	  break;
4857              	}
4858                  }
4859                else
4860                  {
4861                    ID(mul);
4862                  }
4863                DR(rdst); SC(val); F_____;
4864
4865              }
4866            break;
4867          case 0x20:
4868            op_semantics_34:
4869              {
4870                /** 0111 01im 0010 rdst			and	#%1, %0 */
4871#line 438 "rx-decode.opc"
4872                int im AU = op[0] & 0x03;
4873#line 438 "rx-decode.opc"
4874                int rdst AU = op[1] & 0x0f;
4875                if (trace)
4876                  {
4877                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4878                           "/** 0111 01im 0010 rdst			and	#%1, %0 */",
4879                           op[0], op[1]);
4880                    printf ("  im = 0x%x,", im);
4881                    printf ("  rdst = 0x%x\n", rdst);
4882                  }
4883                SYNTAX("and	#%1, %0");
4884#line 438 "rx-decode.opc"
4885                ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4886
4887              }
4888            break;
4889          case 0x30:
4890            op_semantics_35:
4891              {
4892                /** 0111 01im 0011 rdst			or	#%1, %0 */
4893#line 456 "rx-decode.opc"
4894                int im AU = op[0] & 0x03;
4895#line 456 "rx-decode.opc"
4896                int rdst AU = op[1] & 0x0f;
4897                if (trace)
4898                  {
4899                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4900                           "/** 0111 01im 0011 rdst			or	#%1, %0 */",
4901                           op[0], op[1]);
4902                    printf ("  im = 0x%x,", im);
4903                    printf ("  rdst = 0x%x\n", rdst);
4904                  }
4905                SYNTAX("or	#%1, %0");
4906#line 456 "rx-decode.opc"
4907                ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4908
4909              }
4910            break;
4911          default: UNSUPPORTED(); break;
4912        }
4913      break;
4914    case 0x75:
4915        GETBYTE ();
4916        switch (op[1] & 0xff)
4917        {
4918          case 0x00:
4919          case 0x01:
4920          case 0x02:
4921          case 0x03:
4922          case 0x04:
4923          case 0x05:
4924          case 0x06:
4925          case 0x07:
4926          case 0x08:
4927          case 0x09:
4928          case 0x0a:
4929          case 0x0b:
4930          case 0x0c:
4931          case 0x0d:
4932          case 0x0e:
4933          case 0x0f:
4934            goto op_semantics_32;
4935            break;
4936          case 0x10:
4937          case 0x11:
4938          case 0x12:
4939          case 0x13:
4940          case 0x14:
4941          case 0x15:
4942          case 0x16:
4943          case 0x17:
4944          case 0x18:
4945          case 0x19:
4946          case 0x1a:
4947          case 0x1b:
4948          case 0x1c:
4949          case 0x1d:
4950          case 0x1e:
4951          case 0x1f:
4952            goto op_semantics_33;
4953            break;
4954          case 0x20:
4955          case 0x21:
4956          case 0x22:
4957          case 0x23:
4958          case 0x24:
4959          case 0x25:
4960          case 0x26:
4961          case 0x27:
4962          case 0x28:
4963          case 0x29:
4964          case 0x2a:
4965          case 0x2b:
4966          case 0x2c:
4967          case 0x2d:
4968          case 0x2e:
4969          case 0x2f:
4970            goto op_semantics_34;
4971            break;
4972          case 0x30:
4973          case 0x31:
4974          case 0x32:
4975          case 0x33:
4976          case 0x34:
4977          case 0x35:
4978          case 0x36:
4979          case 0x37:
4980          case 0x38:
4981          case 0x39:
4982          case 0x3a:
4983          case 0x3b:
4984          case 0x3c:
4985          case 0x3d:
4986          case 0x3e:
4987          case 0x3f:
4988            goto op_semantics_35;
4989            break;
4990          case 0x40:
4991          case 0x41:
4992          case 0x42:
4993          case 0x43:
4994          case 0x44:
4995          case 0x45:
4996          case 0x46:
4997          case 0x47:
4998          case 0x48:
4999          case 0x49:
5000          case 0x4a:
5001          case 0x4b:
5002          case 0x4c:
5003          case 0x4d:
5004          case 0x4e:
5005          case 0x4f:
5006              {
5007                /** 0111 0101 0100 rdst		mov%s	#%1, %0 */
5008#line 310 "rx-decode.opc"
5009                int rdst AU = op[1] & 0x0f;
5010                if (trace)
5011                  {
5012                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5013                           "/** 0111 0101 0100 rdst		mov%s	#%1, %0 */",
5014                           op[0], op[1]);
5015                    printf ("  rdst = 0x%x\n", rdst);
5016                  }
5017                SYNTAX("mov%s	#%1, %0");
5018#line 310 "rx-decode.opc"
5019                ID(mov); DR(rdst); SC(IMM (1)); F_____;
5020
5021              }
5022            break;
5023          case 0x50:
5024          case 0x51:
5025          case 0x52:
5026          case 0x53:
5027          case 0x54:
5028          case 0x55:
5029          case 0x56:
5030          case 0x57:
5031          case 0x58:
5032          case 0x59:
5033          case 0x5a:
5034          case 0x5b:
5035          case 0x5c:
5036          case 0x5d:
5037          case 0x5e:
5038          case 0x5f:
5039              {
5040                /** 0111 0101 0101 rsrc			cmp	#%2, %1 */
5041#line 549 "rx-decode.opc"
5042                int rsrc AU = op[1] & 0x0f;
5043                if (trace)
5044                  {
5045                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5046                           "/** 0111 0101 0101 rsrc			cmp	#%2, %1 */",
5047                           op[0], op[1]);
5048                    printf ("  rsrc = 0x%x\n", rsrc);
5049                  }
5050                SYNTAX("cmp	#%2, %1");
5051#line 549 "rx-decode.opc"
5052                ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5053
5054              }
5055            break;
5056          case 0x60:
5057              {
5058                /** 0111 0101 0110 0000		int #%1 */
5059                if (trace)
5060                  {
5061                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5062                           "/** 0111 0101 0110 0000		int #%1 */",
5063                           op[0], op[1]);
5064                  }
5065                SYNTAX("int #%1");
5066#line 1056 "rx-decode.opc"
5067                ID(int); SC(IMM(1));
5068
5069              }
5070            break;
5071          case 0x70:
5072              GETBYTE ();
5073              switch (op[2] & 0xf0)
5074              {
5075                case 0x00:
5076                    {
5077                      /** 0111 0101 0111 0000 0000 immm	mvtipl	#%1 */
5078#line 1023 "rx-decode.opc"
5079                      int immm AU = op[2] & 0x0f;
5080                      if (trace)
5081                        {
5082                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5083                                 "/** 0111 0101 0111 0000 0000 immm	mvtipl	#%1 */",
5084                                 op[0], op[1], op[2]);
5085                          printf ("  immm = 0x%x\n", immm);
5086                        }
5087                      SYNTAX("mvtipl	#%1");
5088#line 1023 "rx-decode.opc"
5089                      ID(mvtipl); SC(immm);
5090
5091                    }
5092                  break;
5093                default: UNSUPPORTED(); break;
5094              }
5095            break;
5096          case 0x90:
5097              GETBYTE ();
5098              switch (op[2] & 0xff)
5099              {
5100                case 0x1b:
5101                    {
5102                      /** 0111 0101 1001 0000 0001 1011	mvfdr */
5103                      if (trace)
5104                        {
5105                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5106                                 "/** 0111 0101 1001 0000 0001 1011	mvfdr */",
5107                                 op[0], op[1], op[2]);
5108                        }
5109                      SYNTAX("mvfdr");
5110#line 1229 "rx-decode.opc"
5111                      ID(mvfdr); F_____;
5112
5113                    }
5114                  break;
5115                default: UNSUPPORTED(); break;
5116              }
5117            break;
5118          case 0xa0:
5119              GETBYTE ();
5120              switch (op[2] & 0x00)
5121              {
5122                case 0x00:
5123                    {
5124                      /** 0111 0101 1010 0000 rdst rnum	dpushm.l	%1-%2 */
5125#line 1223 "rx-decode.opc"
5126                      int rdst AU = (op[2] >> 4) & 0x0f;
5127#line 1223 "rx-decode.opc"
5128                      int rnum AU = op[2] & 0x0f;
5129                      if (trace)
5130                        {
5131                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5132                                 "/** 0111 0101 1010 0000 rdst rnum	dpushm.l	%1-%2 */",
5133                                 op[0], op[1], op[2]);
5134                          printf ("  rdst = 0x%x,", rdst);
5135                          printf ("  rnum = 0x%x\n", rnum);
5136                        }
5137                      SYNTAX("dpushm.l	%1-%2");
5138#line 1223 "rx-decode.opc"
5139                      ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
5140
5141                    }
5142                  break;
5143              }
5144            break;
5145          case 0xa8:
5146              GETBYTE ();
5147              switch (op[2] & 0x00)
5148              {
5149                case 0x00:
5150                    {
5151                      /** 0111 0101 1010 1000 rdst rnum	dpopm.l	%1-%2 */
5152#line 1217 "rx-decode.opc"
5153                      int rdst AU = (op[2] >> 4) & 0x0f;
5154#line 1217 "rx-decode.opc"
5155                      int rnum AU = op[2] & 0x0f;
5156                      if (trace)
5157                        {
5158                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5159                                 "/** 0111 0101 1010 1000 rdst rnum	dpopm.l	%1-%2 */",
5160                                 op[0], op[1], op[2]);
5161                          printf ("  rdst = 0x%x,", rdst);
5162                          printf ("  rnum = 0x%x\n", rnum);
5163                        }
5164                      SYNTAX("dpopm.l	%1-%2");
5165#line 1217 "rx-decode.opc"
5166                      ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
5167
5168                    }
5169                  break;
5170              }
5171            break;
5172          case 0xb0:
5173              GETBYTE ();
5174              switch (op[2] & 0x00)
5175              {
5176                case 0x00:
5177                    {
5178                      /** 0111 0101 1011 0000 rdst rnum	dpushm.d	%1-%2 */
5179#line 1220 "rx-decode.opc"
5180                      int rdst AU = (op[2] >> 4) & 0x0f;
5181#line 1220 "rx-decode.opc"
5182                      int rnum AU = op[2] & 0x0f;
5183                      if (trace)
5184                        {
5185                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5186                                 "/** 0111 0101 1011 0000 rdst rnum	dpushm.d	%1-%2 */",
5187                                 op[0], op[1], op[2]);
5188                          printf ("  rdst = 0x%x,", rdst);
5189                          printf ("  rnum = 0x%x\n", rnum);
5190                        }
5191                      SYNTAX("dpushm.d	%1-%2");
5192#line 1220 "rx-decode.opc"
5193                      ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
5194
5195                    }
5196                  break;
5197              }
5198            break;
5199          case 0xb8:
5200              GETBYTE ();
5201              switch (op[2] & 0x00)
5202              {
5203                case 0x00:
5204                    {
5205                      /** 0111 0101 1011 1000 rdst rnum	dpopm.d	%1-%2 */
5206#line 1214 "rx-decode.opc"
5207                      int rdst AU = (op[2] >> 4) & 0x0f;
5208#line 1214 "rx-decode.opc"
5209                      int rnum AU = op[2] & 0x0f;
5210                      if (trace)
5211                        {
5212                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5213                                 "/** 0111 0101 1011 1000 rdst rnum	dpopm.d	%1-%2 */",
5214                                 op[0], op[1], op[2]);
5215                          printf ("  rdst = 0x%x,", rdst);
5216                          printf ("  rnum = 0x%x\n", rnum);
5217                        }
5218                      SYNTAX("dpopm.d	%1-%2");
5219#line 1214 "rx-decode.opc"
5220                      ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221
5222                    }
5223                  break;
5224              }
5225            break;
5226          default: UNSUPPORTED(); break;
5227        }
5228      break;
5229    case 0x76:
5230        GETBYTE ();
5231        switch (op[1] & 0xff)
5232        {
5233          case 0x00:
5234          case 0x01:
5235          case 0x02:
5236          case 0x03:
5237          case 0x04:
5238          case 0x05:
5239          case 0x06:
5240          case 0x07:
5241          case 0x08:
5242          case 0x09:
5243          case 0x0a:
5244          case 0x0b:
5245          case 0x0c:
5246          case 0x0d:
5247          case 0x0e:
5248          case 0x0f:
5249            goto op_semantics_32;
5250            break;
5251          case 0x10:
5252          case 0x11:
5253          case 0x12:
5254          case 0x13:
5255          case 0x14:
5256          case 0x15:
5257          case 0x16:
5258          case 0x17:
5259          case 0x18:
5260          case 0x19:
5261          case 0x1a:
5262          case 0x1b:
5263          case 0x1c:
5264          case 0x1d:
5265          case 0x1e:
5266          case 0x1f:
5267            goto op_semantics_33;
5268            break;
5269          case 0x20:
5270          case 0x21:
5271          case 0x22:
5272          case 0x23:
5273          case 0x24:
5274          case 0x25:
5275          case 0x26:
5276          case 0x27:
5277          case 0x28:
5278          case 0x29:
5279          case 0x2a:
5280          case 0x2b:
5281          case 0x2c:
5282          case 0x2d:
5283          case 0x2e:
5284          case 0x2f:
5285            goto op_semantics_34;
5286            break;
5287          case 0x30:
5288          case 0x31:
5289          case 0x32:
5290          case 0x33:
5291          case 0x34:
5292          case 0x35:
5293          case 0x36:
5294          case 0x37:
5295          case 0x38:
5296          case 0x39:
5297          case 0x3a:
5298          case 0x3b:
5299          case 0x3c:
5300          case 0x3d:
5301          case 0x3e:
5302          case 0x3f:
5303            goto op_semantics_35;
5304            break;
5305          case 0x90:
5306              GETBYTE ();
5307              switch (op[2] & 0xff)
5308              {
5309                case 0x00:
5310                    GETBYTE ();
5311                    switch (op[3] & 0x00)
5312                    {
5313                      case 0x00:
5314                        op_semantics_36:
5315                          {
5316                            /** 0111 0110 1001 0000 srcb 0000 rdst srca	dadd	%1, %2, %0 */
5317#line 1238 "rx-decode.opc"
5318                            int srcb AU = (op[2] >> 4) & 0x0f;
5319#line 1238 "rx-decode.opc"
5320                            int rdst AU = (op[3] >> 4) & 0x0f;
5321#line 1238 "rx-decode.opc"
5322                            int srca AU = op[3] & 0x0f;
5323                            if (trace)
5324                              {
5325                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5326                                       "/** 0111 0110 1001 0000 srcb 0000 rdst srca	dadd	%1, %2, %0 */",
5327                                       op[0], op[1], op[2], op[3]);
5328                                printf ("  srcb = 0x%x,", srcb);
5329                                printf ("  rdst = 0x%x,", rdst);
5330                                printf ("  srca = 0x%x\n", srca);
5331                              }
5332                            SYNTAX("dadd	%1, %2, %0");
5333#line 1238 "rx-decode.opc"
5334                            ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335
5336                          }
5337                        break;
5338                    }
5339                  break;
5340                case 0x01:
5341                    GETBYTE ();
5342                    switch (op[3] & 0x00)
5343                    {
5344                      case 0x00:
5345                        op_semantics_37:
5346                          {
5347                            /** 0111 0110 1001 0000 srcb 0001 rdst srca	dsub	%1, %2, %0 */
5348#line 1259 "rx-decode.opc"
5349                            int srcb AU = (op[2] >> 4) & 0x0f;
5350#line 1259 "rx-decode.opc"
5351                            int rdst AU = (op[3] >> 4) & 0x0f;
5352#line 1259 "rx-decode.opc"
5353                            int srca AU = op[3] & 0x0f;
5354                            if (trace)
5355                              {
5356                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5357                                       "/** 0111 0110 1001 0000 srcb 0001 rdst srca	dsub	%1, %2, %0 */",
5358                                       op[0], op[1], op[2], op[3]);
5359                                printf ("  srcb = 0x%x,", srcb);
5360                                printf ("  rdst = 0x%x,", rdst);
5361                                printf ("  srca = 0x%x\n", srca);
5362                              }
5363                            SYNTAX("dsub	%1, %2, %0");
5364#line 1259 "rx-decode.opc"
5365                            ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366
5367                          }
5368                        break;
5369                    }
5370                  break;
5371                case 0x02:
5372                    GETBYTE ();
5373                    switch (op[3] & 0x00)
5374                    {
5375                      case 0x00:
5376                        op_semantics_38:
5377                          {
5378                            /** 0111 0110 1001 0000 srcb 0010 rdst srca	dmul	%1, %2, %0 */
5379#line 1247 "rx-decode.opc"
5380                            int srcb AU = (op[2] >> 4) & 0x0f;
5381#line 1247 "rx-decode.opc"
5382                            int rdst AU = (op[3] >> 4) & 0x0f;
5383#line 1247 "rx-decode.opc"
5384                            int srca AU = op[3] & 0x0f;
5385                            if (trace)
5386                              {
5387                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5388                                       "/** 0111 0110 1001 0000 srcb 0010 rdst srca	dmul	%1, %2, %0 */",
5389                                       op[0], op[1], op[2], op[3]);
5390                                printf ("  srcb = 0x%x,", srcb);
5391                                printf ("  rdst = 0x%x,", rdst);
5392                                printf ("  srca = 0x%x\n", srca);
5393                              }
5394                            SYNTAX("dmul	%1, %2, %0");
5395#line 1247 "rx-decode.opc"
5396                            ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397
5398                          }
5399                        break;
5400                    }
5401                  break;
5402                case 0x05:
5403                    GETBYTE ();
5404                    switch (op[3] & 0x00)
5405                    {
5406                      case 0x00:
5407                        op_semantics_39:
5408                          {
5409                            /** 0111 0110 1001 0000 srcb 0101 rdst srca	ddiv	%1, %2, %0 */
5410#line 1244 "rx-decode.opc"
5411                            int srcb AU = (op[2] >> 4) & 0x0f;
5412#line 1244 "rx-decode.opc"
5413                            int rdst AU = (op[3] >> 4) & 0x0f;
5414#line 1244 "rx-decode.opc"
5415                            int srca AU = op[3] & 0x0f;
5416                            if (trace)
5417                              {
5418                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5419                                       "/** 0111 0110 1001 0000 srcb 0101 rdst srca	ddiv	%1, %2, %0 */",
5420                                       op[0], op[1], op[2], op[3]);
5421                                printf ("  srcb = 0x%x,", srcb);
5422                                printf ("  rdst = 0x%x,", rdst);
5423                                printf ("  srca = 0x%x\n", srca);
5424                              }
5425                            SYNTAX("ddiv	%1, %2, %0");
5426#line 1244 "rx-decode.opc"
5427                            ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428
5429                          }
5430                        break;
5431                    }
5432                  break;
5433                case 0x08:
5434                    GETBYTE ();
5435                    switch (op[3] & 0x00)
5436                    {
5437                      case 0x00:
5438                        op_semantics_40:
5439                          {
5440                            /** 0111 0110 1001 0000 srcb 1000 cond srca	dcmp%0	%1, %2 */
5441#line 1241 "rx-decode.opc"
5442                            int srcb AU = (op[2] >> 4) & 0x0f;
5443#line 1241 "rx-decode.opc"
5444                            int cond AU = (op[3] >> 4) & 0x0f;
5445#line 1241 "rx-decode.opc"
5446                            int srca AU = op[3] & 0x0f;
5447                            if (trace)
5448                              {
5449                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5450                                       "/** 0111 0110 1001 0000 srcb 1000 cond srca	dcmp%0	%1, %2 */",
5451                                       op[0], op[1], op[2], op[3]);
5452                                printf ("  srcb = 0x%x,", srcb);
5453                                printf ("  cond = 0x%x,", cond);
5454                                printf ("  srca = 0x%x\n", srca);
5455                              }
5456                            SYNTAX("dcmp%0	%1, %2");
5457#line 1241 "rx-decode.opc"
5458                            ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459
5460                          }
5461                        break;
5462                    }
5463                  break;
5464                case 0x0c:
5465                    GETBYTE ();
5466                    switch (op[3] & 0x0f)
5467                    {
5468                      case 0x00:
5469                        op_semantics_41:
5470                          {
5471                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0000	dmov.d	%1, %0 */
5472#line 1179 "rx-decode.opc"
5473                            int rsrc AU = (op[2] >> 4) & 0x0f;
5474#line 1179 "rx-decode.opc"
5475                            int rdst AU = (op[3] >> 4) & 0x0f;
5476                            if (trace)
5477                              {
5478                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5479                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000	dmov.d	%1, %0 */",
5480                                       op[0], op[1], op[2], op[3]);
5481                                printf ("  rsrc = 0x%x,", rsrc);
5482                                printf ("  rdst = 0x%x\n", rdst);
5483                              }
5484                            SYNTAX("dmov.d	%1, %0");
5485#line 1179 "rx-decode.opc"
5486                            ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487
5488                          }
5489                        break;
5490                      case 0x01:
5491                        op_semantics_42:
5492                          {
5493                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0001	dabs	%1, %0 */
5494#line 1235 "rx-decode.opc"
5495                            int rsrc AU = (op[2] >> 4) & 0x0f;
5496#line 1235 "rx-decode.opc"
5497                            int rdst AU = (op[3] >> 4) & 0x0f;
5498                            if (trace)
5499                              {
5500                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5501                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001	dabs	%1, %0 */",
5502                                       op[0], op[1], op[2], op[3]);
5503                                printf ("  rsrc = 0x%x,", rsrc);
5504                                printf ("  rdst = 0x%x\n", rdst);
5505                              }
5506                            SYNTAX("dabs	%1, %0");
5507#line 1235 "rx-decode.opc"
5508                            ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509
5510                          }
5511                        break;
5512                      case 0x02:
5513                        op_semantics_43:
5514                          {
5515                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0010	dneg	%1, %0 */
5516#line 1250 "rx-decode.opc"
5517                            int rsrc AU = (op[2] >> 4) & 0x0f;
5518#line 1250 "rx-decode.opc"
5519                            int rdst AU = (op[3] >> 4) & 0x0f;
5520                            if (trace)
5521                              {
5522                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5523                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010	dneg	%1, %0 */",
5524                                       op[0], op[1], op[2], op[3]);
5525                                printf ("  rsrc = 0x%x,", rsrc);
5526                                printf ("  rdst = 0x%x\n", rdst);
5527                              }
5528                            SYNTAX("dneg	%1, %0");
5529#line 1250 "rx-decode.opc"
5530                            ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531
5532                          }
5533                        break;
5534                      default: UNSUPPORTED(); break;
5535                    }
5536                  break;
5537                case 0x0d:
5538                    GETBYTE ();
5539                    switch (op[3] & 0x0f)
5540                    {
5541                      case 0x00:
5542                        op_semantics_44:
5543                          {
5544                            /** 0111 0110 1001 0000 rsrc 1101 rdst 0000	dsqrt	%1, %0 */
5545#line 1256 "rx-decode.opc"
5546                            int rsrc AU = (op[2] >> 4) & 0x0f;
5547#line 1256 "rx-decode.opc"
5548                            int rdst AU = (op[3] >> 4) & 0x0f;
5549                            if (trace)
5550                              {
5551                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5552                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000	dsqrt	%1, %0 */",
5553                                       op[0], op[1], op[2], op[3]);
5554                                printf ("  rsrc = 0x%x,", rsrc);
5555                                printf ("  rdst = 0x%x\n", rdst);
5556                              }
5557                            SYNTAX("dsqrt	%1, %0");
5558#line 1256 "rx-decode.opc"
5559                            ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560
5561                          }
5562                        break;
5563                      case 0x08:
5564                        op_semantics_45:
5565                          {
5566                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1000	dtoi	%1, %0 */
5567#line 1265 "rx-decode.opc"
5568                            int rsrc AU = (op[2] >> 4) & 0x0f;
5569#line 1265 "rx-decode.opc"
5570                            int rdst AU = (op[3] >> 4) & 0x0f;
5571                            if (trace)
5572                              {
5573                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5574                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000	dtoi	%1, %0 */",
5575                                       op[0], op[1], op[2], op[3]);
5576                                printf ("  rsrc = 0x%x,", rsrc);
5577                                printf ("  rdst = 0x%x\n", rdst);
5578                              }
5579                            SYNTAX("dtoi	%1, %0");
5580#line 1265 "rx-decode.opc"
5581                            ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582
5583                          }
5584                        break;
5585                      case 0x09:
5586                        op_semantics_46:
5587                          {
5588                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1001	dtou	%1, %0 */
5589#line 1268 "rx-decode.opc"
5590                            int rsrc AU = (op[2] >> 4) & 0x0f;
5591#line 1268 "rx-decode.opc"
5592                            int rdst AU = (op[3] >> 4) & 0x0f;
5593                            if (trace)
5594                              {
5595                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5596                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001	dtou	%1, %0 */",
5597                                       op[0], op[1], op[2], op[3]);
5598                                printf ("  rsrc = 0x%x,", rsrc);
5599                                printf ("  rdst = 0x%x\n", rdst);
5600                              }
5601                            SYNTAX("dtou	%1, %0");
5602#line 1268 "rx-decode.opc"
5603                            ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604
5605                          }
5606                        break;
5607                      case 0x0c:
5608                        op_semantics_47:
5609                          {
5610                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1100	dtof	%1, %0 */
5611#line 1262 "rx-decode.opc"
5612                            int rsrc AU = (op[2] >> 4) & 0x0f;
5613#line 1262 "rx-decode.opc"
5614                            int rdst AU = (op[3] >> 4) & 0x0f;
5615                            if (trace)
5616                              {
5617                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5618                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100	dtof	%1, %0 */",
5619                                       op[0], op[1], op[2], op[3]);
5620                                printf ("  rsrc = 0x%x,", rsrc);
5621                                printf ("  rdst = 0x%x\n", rdst);
5622                              }
5623                            SYNTAX("dtof	%1, %0");
5624#line 1262 "rx-decode.opc"
5625                            ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626
5627                          }
5628                        break;
5629                      case 0x0d:
5630                        op_semantics_48:
5631                          {
5632                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1101	dround	%1, %0 */
5633#line 1253 "rx-decode.opc"
5634                            int rsrc AU = (op[2] >> 4) & 0x0f;
5635#line 1253 "rx-decode.opc"
5636                            int rdst AU = (op[3] >> 4) & 0x0f;
5637                            if (trace)
5638                              {
5639                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5640                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101	dround	%1, %0 */",
5641                                       op[0], op[1], op[2], op[3]);
5642                                printf ("  rsrc = 0x%x,", rsrc);
5643                                printf ("  rdst = 0x%x\n", rdst);
5644                              }
5645                            SYNTAX("dround	%1, %0");
5646#line 1253 "rx-decode.opc"
5647                            ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648
5649                          }
5650                        break;
5651                      default: UNSUPPORTED(); break;
5652                    }
5653                  break;
5654                case 0x10:
5655                    GETBYTE ();
5656                    switch (op[3] & 0x00)
5657                    {
5658                      case 0x00:
5659                        goto op_semantics_36;
5660                        break;
5661                    }
5662                  break;
5663                case 0x11:
5664                    GETBYTE ();
5665                    switch (op[3] & 0x00)
5666                    {
5667                      case 0x00:
5668                        goto op_semantics_37;
5669                        break;
5670                    }
5671                  break;
5672                case 0x12:
5673                    GETBYTE ();
5674                    switch (op[3] & 0x00)
5675                    {
5676                      case 0x00:
5677                        goto op_semantics_38;
5678                        break;
5679                    }
5680                  break;
5681                case 0x15:
5682                    GETBYTE ();
5683                    switch (op[3] & 0x00)
5684                    {
5685                      case 0x00:
5686                        goto op_semantics_39;
5687                        break;
5688                    }
5689                  break;
5690                case 0x18:
5691                    GETBYTE ();
5692                    switch (op[3] & 0x00)
5693                    {
5694                      case 0x00:
5695                        goto op_semantics_40;
5696                        break;
5697                    }
5698                  break;
5699                case 0x1c:
5700                    GETBYTE ();
5701                    switch (op[3] & 0x0f)
5702                    {
5703                      case 0x00:
5704                        goto op_semantics_41;
5705                        break;
5706                      case 0x01:
5707                        goto op_semantics_42;
5708                        break;
5709                      case 0x02:
5710                        goto op_semantics_43;
5711                        break;
5712                      default: UNSUPPORTED(); break;
5713                    }
5714                  break;
5715                case 0x1d:
5716                    GETBYTE ();
5717                    switch (op[3] & 0x0f)
5718                    {
5719                      case 0x00:
5720                        goto op_semantics_44;
5721                        break;
5722                      case 0x08:
5723                        goto op_semantics_45;
5724                        break;
5725                      case 0x09:
5726                        goto op_semantics_46;
5727                        break;
5728                      case 0x0c:
5729                        goto op_semantics_47;
5730                        break;
5731                      case 0x0d:
5732                        goto op_semantics_48;
5733                        break;
5734                      default: UNSUPPORTED(); break;
5735                    }
5736                  break;
5737                case 0x20:
5738                    GETBYTE ();
5739                    switch (op[3] & 0x00)
5740                    {
5741                      case 0x00:
5742                        goto op_semantics_36;
5743                        break;
5744                    }
5745                  break;
5746                case 0x21:
5747                    GETBYTE ();
5748                    switch (op[3] & 0x00)
5749                    {
5750                      case 0x00:
5751                        goto op_semantics_37;
5752                        break;
5753                    }
5754                  break;
5755                case 0x22:
5756                    GETBYTE ();
5757                    switch (op[3] & 0x00)
5758                    {
5759                      case 0x00:
5760                        goto op_semantics_38;
5761                        break;
5762                    }
5763                  break;
5764                case 0x25:
5765                    GETBYTE ();
5766                    switch (op[3] & 0x00)
5767                    {
5768                      case 0x00:
5769                        goto op_semantics_39;
5770                        break;
5771                    }
5772                  break;
5773                case 0x28:
5774                    GETBYTE ();
5775                    switch (op[3] & 0x00)
5776                    {
5777                      case 0x00:
5778                        goto op_semantics_40;
5779                        break;
5780                    }
5781                  break;
5782                case 0x2c:
5783                    GETBYTE ();
5784                    switch (op[3] & 0x0f)
5785                    {
5786                      case 0x00:
5787                        goto op_semantics_41;
5788                        break;
5789                      case 0x01:
5790                        goto op_semantics_42;
5791                        break;
5792                      case 0x02:
5793                        goto op_semantics_43;
5794                        break;
5795                      default: UNSUPPORTED(); break;
5796                    }
5797                  break;
5798                case 0x2d:
5799                    GETBYTE ();
5800                    switch (op[3] & 0x0f)
5801                    {
5802                      case 0x00:
5803                        goto op_semantics_44;
5804                        break;
5805                      case 0x08:
5806                        goto op_semantics_45;
5807                        break;
5808                      case 0x09:
5809                        goto op_semantics_46;
5810                        break;
5811                      case 0x0c:
5812                        goto op_semantics_47;
5813                        break;
5814                      case 0x0d:
5815                        goto op_semantics_48;
5816                        break;
5817                      default: UNSUPPORTED(); break;
5818                    }
5819                  break;
5820                case 0x30:
5821                    GETBYTE ();
5822                    switch (op[3] & 0x00)
5823                    {
5824                      case 0x00:
5825                        goto op_semantics_36;
5826                        break;
5827                    }
5828                  break;
5829                case 0x31:
5830                    GETBYTE ();
5831                    switch (op[3] & 0x00)
5832                    {
5833                      case 0x00:
5834                        goto op_semantics_37;
5835                        break;
5836                    }
5837                  break;
5838                case 0x32:
5839                    GETBYTE ();
5840                    switch (op[3] & 0x00)
5841                    {
5842                      case 0x00:
5843                        goto op_semantics_38;
5844                        break;
5845                    }
5846                  break;
5847                case 0x35:
5848                    GETBYTE ();
5849                    switch (op[3] & 0x00)
5850                    {
5851                      case 0x00:
5852                        goto op_semantics_39;
5853                        break;
5854                    }
5855                  break;
5856                case 0x38:
5857                    GETBYTE ();
5858                    switch (op[3] & 0x00)
5859                    {
5860                      case 0x00:
5861                        goto op_semantics_40;
5862                        break;
5863                    }
5864                  break;
5865                case 0x3c:
5866                    GETBYTE ();
5867                    switch (op[3] & 0x0f)
5868                    {
5869                      case 0x00:
5870                        goto op_semantics_41;
5871                        break;
5872                      case 0x01:
5873                        goto op_semantics_42;
5874                        break;
5875                      case 0x02:
5876                        goto op_semantics_43;
5877                        break;
5878                      default: UNSUPPORTED(); break;
5879                    }
5880                  break;
5881                case 0x3d:
5882                    GETBYTE ();
5883                    switch (op[3] & 0x0f)
5884                    {
5885                      case 0x00:
5886                        goto op_semantics_44;
5887                        break;
5888                      case 0x08:
5889                        goto op_semantics_45;
5890                        break;
5891                      case 0x09:
5892                        goto op_semantics_46;
5893                        break;
5894                      case 0x0c:
5895                        goto op_semantics_47;
5896                        break;
5897                      case 0x0d:
5898                        goto op_semantics_48;
5899                        break;
5900                      default: UNSUPPORTED(); break;
5901                    }
5902                  break;
5903                case 0x40:
5904                    GETBYTE ();
5905                    switch (op[3] & 0x00)
5906                    {
5907                      case 0x00:
5908                        goto op_semantics_36;
5909                        break;
5910                    }
5911                  break;
5912                case 0x41:
5913                    GETBYTE ();
5914                    switch (op[3] & 0x00)
5915                    {
5916                      case 0x00:
5917                        goto op_semantics_37;
5918                        break;
5919                    }
5920                  break;
5921                case 0x42:
5922                    GETBYTE ();
5923                    switch (op[3] & 0x00)
5924                    {
5925                      case 0x00:
5926                        goto op_semantics_38;
5927                        break;
5928                    }
5929                  break;
5930                case 0x45:
5931                    GETBYTE ();
5932                    switch (op[3] & 0x00)
5933                    {
5934                      case 0x00:
5935                        goto op_semantics_39;
5936                        break;
5937                    }
5938                  break;
5939                case 0x48:
5940                    GETBYTE ();
5941                    switch (op[3] & 0x00)
5942                    {
5943                      case 0x00:
5944                        goto op_semantics_40;
5945                        break;
5946                    }
5947                  break;
5948                case 0x4c:
5949                    GETBYTE ();
5950                    switch (op[3] & 0x0f)
5951                    {
5952                      case 0x00:
5953                        goto op_semantics_41;
5954                        break;
5955                      case 0x01:
5956                        goto op_semantics_42;
5957                        break;
5958                      case 0x02:
5959                        goto op_semantics_43;
5960                        break;
5961                      default: UNSUPPORTED(); break;
5962                    }
5963                  break;
5964                case 0x4d:
5965                    GETBYTE ();
5966                    switch (op[3] & 0x0f)
5967                    {
5968                      case 0x00:
5969                        goto op_semantics_44;
5970                        break;
5971                      case 0x08:
5972                        goto op_semantics_45;
5973                        break;
5974                      case 0x09:
5975                        goto op_semantics_46;
5976                        break;
5977                      case 0x0c:
5978                        goto op_semantics_47;
5979                        break;
5980                      case 0x0d:
5981                        goto op_semantics_48;
5982                        break;
5983                      default: UNSUPPORTED(); break;
5984                    }
5985                  break;
5986                case 0x50:
5987                    GETBYTE ();
5988                    switch (op[3] & 0x00)
5989                    {
5990                      case 0x00:
5991                        goto op_semantics_36;
5992                        break;
5993                    }
5994                  break;
5995                case 0x51:
5996                    GETBYTE ();
5997                    switch (op[3] & 0x00)
5998                    {
5999                      case 0x00:
6000                        goto op_semantics_37;
6001                        break;
6002                    }
6003                  break;
6004                case 0x52:
6005                    GETBYTE ();
6006                    switch (op[3] & 0x00)
6007                    {
6008                      case 0x00:
6009                        goto op_semantics_38;
6010                        break;
6011                    }
6012                  break;
6013                case 0x55:
6014                    GETBYTE ();
6015                    switch (op[3] & 0x00)
6016                    {
6017                      case 0x00:
6018                        goto op_semantics_39;
6019                        break;
6020                    }
6021                  break;
6022                case 0x58:
6023                    GETBYTE ();
6024                    switch (op[3] & 0x00)
6025                    {
6026                      case 0x00:
6027                        goto op_semantics_40;
6028                        break;
6029                    }
6030                  break;
6031                case 0x5c:
6032                    GETBYTE ();
6033                    switch (op[3] & 0x0f)
6034                    {
6035                      case 0x00:
6036                        goto op_semantics_41;
6037                        break;
6038                      case 0x01:
6039                        goto op_semantics_42;
6040                        break;
6041                      case 0x02:
6042                        goto op_semantics_43;
6043                        break;
6044                      default: UNSUPPORTED(); break;
6045                    }
6046                  break;
6047                case 0x5d:
6048                    GETBYTE ();
6049                    switch (op[3] & 0x0f)
6050                    {
6051                      case 0x00:
6052                        goto op_semantics_44;
6053                        break;
6054                      case 0x08:
6055                        goto op_semantics_45;
6056                        break;
6057                      case 0x09:
6058                        goto op_semantics_46;
6059                        break;
6060                      case 0x0c:
6061                        goto op_semantics_47;
6062                        break;
6063                      case 0x0d:
6064                        goto op_semantics_48;
6065                        break;
6066                      default: UNSUPPORTED(); break;
6067                    }
6068                  break;
6069                case 0x60:
6070                    GETBYTE ();
6071                    switch (op[3] & 0x00)
6072                    {
6073                      case 0x00:
6074                        goto op_semantics_36;
6075                        break;
6076                    }
6077                  break;
6078                case 0x61:
6079                    GETBYTE ();
6080                    switch (op[3] & 0x00)
6081                    {
6082                      case 0x00:
6083                        goto op_semantics_37;
6084                        break;
6085                    }
6086                  break;
6087                case 0x62:
6088                    GETBYTE ();
6089                    switch (op[3] & 0x00)
6090                    {
6091                      case 0x00:
6092                        goto op_semantics_38;
6093                        break;
6094                    }
6095                  break;
6096                case 0x65:
6097                    GETBYTE ();
6098                    switch (op[3] & 0x00)
6099                    {
6100                      case 0x00:
6101                        goto op_semantics_39;
6102                        break;
6103                    }
6104                  break;
6105                case 0x68:
6106                    GETBYTE ();
6107                    switch (op[3] & 0x00)
6108                    {
6109                      case 0x00:
6110                        goto op_semantics_40;
6111                        break;
6112                    }
6113                  break;
6114                case 0x6c:
6115                    GETBYTE ();
6116                    switch (op[3] & 0x0f)
6117                    {
6118                      case 0x00:
6119                        goto op_semantics_41;
6120                        break;
6121                      case 0x01:
6122                        goto op_semantics_42;
6123                        break;
6124                      case 0x02:
6125                        goto op_semantics_43;
6126                        break;
6127                      default: UNSUPPORTED(); break;
6128                    }
6129                  break;
6130                case 0x6d:
6131                    GETBYTE ();
6132                    switch (op[3] & 0x0f)
6133                    {
6134                      case 0x00:
6135                        goto op_semantics_44;
6136                        break;
6137                      case 0x08:
6138                        goto op_semantics_45;
6139                        break;
6140                      case 0x09:
6141                        goto op_semantics_46;
6142                        break;
6143                      case 0x0c:
6144                        goto op_semantics_47;
6145                        break;
6146                      case 0x0d:
6147                        goto op_semantics_48;
6148                        break;
6149                      default: UNSUPPORTED(); break;
6150                    }
6151                  break;
6152                case 0x70:
6153                    GETBYTE ();
6154                    switch (op[3] & 0x00)
6155                    {
6156                      case 0x00:
6157                        goto op_semantics_36;
6158                        break;
6159                    }
6160                  break;
6161                case 0x71:
6162                    GETBYTE ();
6163                    switch (op[3] & 0x00)
6164                    {
6165                      case 0x00:
6166                        goto op_semantics_37;
6167                        break;
6168                    }
6169                  break;
6170                case 0x72:
6171                    GETBYTE ();
6172                    switch (op[3] & 0x00)
6173                    {
6174                      case 0x00:
6175                        goto op_semantics_38;
6176                        break;
6177                    }
6178                  break;
6179                case 0x75:
6180                    GETBYTE ();
6181                    switch (op[3] & 0x00)
6182                    {
6183                      case 0x00:
6184                        goto op_semantics_39;
6185                        break;
6186                    }
6187                  break;
6188                case 0x78:
6189                    GETBYTE ();
6190                    switch (op[3] & 0x00)
6191                    {
6192                      case 0x00:
6193                        goto op_semantics_40;
6194                        break;
6195                    }
6196                  break;
6197                case 0x7c:
6198                    GETBYTE ();
6199                    switch (op[3] & 0x0f)
6200                    {
6201                      case 0x00:
6202                        goto op_semantics_41;
6203                        break;
6204                      case 0x01:
6205                        goto op_semantics_42;
6206                        break;
6207                      case 0x02:
6208                        goto op_semantics_43;
6209                        break;
6210                      default: UNSUPPORTED(); break;
6211                    }
6212                  break;
6213                case 0x7d:
6214                    GETBYTE ();
6215                    switch (op[3] & 0x0f)
6216                    {
6217                      case 0x00:
6218                        goto op_semantics_44;
6219                        break;
6220                      case 0x08:
6221                        goto op_semantics_45;
6222                        break;
6223                      case 0x09:
6224                        goto op_semantics_46;
6225                        break;
6226                      case 0x0c:
6227                        goto op_semantics_47;
6228                        break;
6229                      case 0x0d:
6230                        goto op_semantics_48;
6231                        break;
6232                      default: UNSUPPORTED(); break;
6233                    }
6234                  break;
6235                case 0x80:
6236                    GETBYTE ();
6237                    switch (op[3] & 0x00)
6238                    {
6239                      case 0x00:
6240                        goto op_semantics_36;
6241                        break;
6242                    }
6243                  break;
6244                case 0x81:
6245                    GETBYTE ();
6246                    switch (op[3] & 0x00)
6247                    {
6248                      case 0x00:
6249                        goto op_semantics_37;
6250                        break;
6251                    }
6252                  break;
6253                case 0x82:
6254                    GETBYTE ();
6255                    switch (op[3] & 0x00)
6256                    {
6257                      case 0x00:
6258                        goto op_semantics_38;
6259                        break;
6260                    }
6261                  break;
6262                case 0x85:
6263                    GETBYTE ();
6264                    switch (op[3] & 0x00)
6265                    {
6266                      case 0x00:
6267                        goto op_semantics_39;
6268                        break;
6269                    }
6270                  break;
6271                case 0x88:
6272                    GETBYTE ();
6273                    switch (op[3] & 0x00)
6274                    {
6275                      case 0x00:
6276                        goto op_semantics_40;
6277                        break;
6278                    }
6279                  break;
6280                case 0x8c:
6281                    GETBYTE ();
6282                    switch (op[3] & 0x0f)
6283                    {
6284                      case 0x00:
6285                        goto op_semantics_41;
6286                        break;
6287                      case 0x01:
6288                        goto op_semantics_42;
6289                        break;
6290                      case 0x02:
6291                        goto op_semantics_43;
6292                        break;
6293                      default: UNSUPPORTED(); break;
6294                    }
6295                  break;
6296                case 0x8d:
6297                    GETBYTE ();
6298                    switch (op[3] & 0x0f)
6299                    {
6300                      case 0x00:
6301                        goto op_semantics_44;
6302                        break;
6303                      case 0x08:
6304                        goto op_semantics_45;
6305                        break;
6306                      case 0x09:
6307                        goto op_semantics_46;
6308                        break;
6309                      case 0x0c:
6310                        goto op_semantics_47;
6311                        break;
6312                      case 0x0d:
6313                        goto op_semantics_48;
6314                        break;
6315                      default: UNSUPPORTED(); break;
6316                    }
6317                  break;
6318                case 0x90:
6319                    GETBYTE ();
6320                    switch (op[3] & 0x00)
6321                    {
6322                      case 0x00:
6323                        goto op_semantics_36;
6324                        break;
6325                    }
6326                  break;
6327                case 0x91:
6328                    GETBYTE ();
6329                    switch (op[3] & 0x00)
6330                    {
6331                      case 0x00:
6332                        goto op_semantics_37;
6333                        break;
6334                    }
6335                  break;
6336                case 0x92:
6337                    GETBYTE ();
6338                    switch (op[3] & 0x00)
6339                    {
6340                      case 0x00:
6341                        goto op_semantics_38;
6342                        break;
6343                    }
6344                  break;
6345                case 0x95:
6346                    GETBYTE ();
6347                    switch (op[3] & 0x00)
6348                    {
6349                      case 0x00:
6350                        goto op_semantics_39;
6351                        break;
6352                    }
6353                  break;
6354                case 0x98:
6355                    GETBYTE ();
6356                    switch (op[3] & 0x00)
6357                    {
6358                      case 0x00:
6359                        goto op_semantics_40;
6360                        break;
6361                    }
6362                  break;
6363                case 0x9c:
6364                    GETBYTE ();
6365                    switch (op[3] & 0x0f)
6366                    {
6367                      case 0x00:
6368                        goto op_semantics_41;
6369                        break;
6370                      case 0x01:
6371                        goto op_semantics_42;
6372                        break;
6373                      case 0x02:
6374                        goto op_semantics_43;
6375                        break;
6376                      default: UNSUPPORTED(); break;
6377                    }
6378                  break;
6379                case 0x9d:
6380                    GETBYTE ();
6381                    switch (op[3] & 0x0f)
6382                    {
6383                      case 0x00:
6384                        goto op_semantics_44;
6385                        break;
6386                      case 0x08:
6387                        goto op_semantics_45;
6388                        break;
6389                      case 0x09:
6390                        goto op_semantics_46;
6391                        break;
6392                      case 0x0c:
6393                        goto op_semantics_47;
6394                        break;
6395                      case 0x0d:
6396                        goto op_semantics_48;
6397                        break;
6398                      default: UNSUPPORTED(); break;
6399                    }
6400                  break;
6401                case 0xa0:
6402                    GETBYTE ();
6403                    switch (op[3] & 0x00)
6404                    {
6405                      case 0x00:
6406                        goto op_semantics_36;
6407                        break;
6408                    }
6409                  break;
6410                case 0xa1:
6411                    GETBYTE ();
6412                    switch (op[3] & 0x00)
6413                    {
6414                      case 0x00:
6415                        goto op_semantics_37;
6416                        break;
6417                    }
6418                  break;
6419                case 0xa2:
6420                    GETBYTE ();
6421                    switch (op[3] & 0x00)
6422                    {
6423                      case 0x00:
6424                        goto op_semantics_38;
6425                        break;
6426                    }
6427                  break;
6428                case 0xa5:
6429                    GETBYTE ();
6430                    switch (op[3] & 0x00)
6431                    {
6432                      case 0x00:
6433                        goto op_semantics_39;
6434                        break;
6435                    }
6436                  break;
6437                case 0xa8:
6438                    GETBYTE ();
6439                    switch (op[3] & 0x00)
6440                    {
6441                      case 0x00:
6442                        goto op_semantics_40;
6443                        break;
6444                    }
6445                  break;
6446                case 0xac:
6447                    GETBYTE ();
6448                    switch (op[3] & 0x0f)
6449                    {
6450                      case 0x00:
6451                        goto op_semantics_41;
6452                        break;
6453                      case 0x01:
6454                        goto op_semantics_42;
6455                        break;
6456                      case 0x02:
6457                        goto op_semantics_43;
6458                        break;
6459                      default: UNSUPPORTED(); break;
6460                    }
6461                  break;
6462                case 0xad:
6463                    GETBYTE ();
6464                    switch (op[3] & 0x0f)
6465                    {
6466                      case 0x00:
6467                        goto op_semantics_44;
6468                        break;
6469                      case 0x08:
6470                        goto op_semantics_45;
6471                        break;
6472                      case 0x09:
6473                        goto op_semantics_46;
6474                        break;
6475                      case 0x0c:
6476                        goto op_semantics_47;
6477                        break;
6478                      case 0x0d:
6479                        goto op_semantics_48;
6480                        break;
6481                      default: UNSUPPORTED(); break;
6482                    }
6483                  break;
6484                case 0xb0:
6485                    GETBYTE ();
6486                    switch (op[3] & 0x00)
6487                    {
6488                      case 0x00:
6489                        goto op_semantics_36;
6490                        break;
6491                    }
6492                  break;
6493                case 0xb1:
6494                    GETBYTE ();
6495                    switch (op[3] & 0x00)
6496                    {
6497                      case 0x00:
6498                        goto op_semantics_37;
6499                        break;
6500                    }
6501                  break;
6502                case 0xb2:
6503                    GETBYTE ();
6504                    switch (op[3] & 0x00)
6505                    {
6506                      case 0x00:
6507                        goto op_semantics_38;
6508                        break;
6509                    }
6510                  break;
6511                case 0xb5:
6512                    GETBYTE ();
6513                    switch (op[3] & 0x00)
6514                    {
6515                      case 0x00:
6516                        goto op_semantics_39;
6517                        break;
6518                    }
6519                  break;
6520                case 0xb8:
6521                    GETBYTE ();
6522                    switch (op[3] & 0x00)
6523                    {
6524                      case 0x00:
6525                        goto op_semantics_40;
6526                        break;
6527                    }
6528                  break;
6529                case 0xbc:
6530                    GETBYTE ();
6531                    switch (op[3] & 0x0f)
6532                    {
6533                      case 0x00:
6534                        goto op_semantics_41;
6535                        break;
6536                      case 0x01:
6537                        goto op_semantics_42;
6538                        break;
6539                      case 0x02:
6540                        goto op_semantics_43;
6541                        break;
6542                      default: UNSUPPORTED(); break;
6543                    }
6544                  break;
6545                case 0xbd:
6546                    GETBYTE ();
6547                    switch (op[3] & 0x0f)
6548                    {
6549                      case 0x00:
6550                        goto op_semantics_44;
6551                        break;
6552                      case 0x08:
6553                        goto op_semantics_45;
6554                        break;
6555                      case 0x09:
6556                        goto op_semantics_46;
6557                        break;
6558                      case 0x0c:
6559                        goto op_semantics_47;
6560                        break;
6561                      case 0x0d:
6562                        goto op_semantics_48;
6563                        break;
6564                      default: UNSUPPORTED(); break;
6565                    }
6566                  break;
6567                case 0xc0:
6568                    GETBYTE ();
6569                    switch (op[3] & 0x00)
6570                    {
6571                      case 0x00:
6572                        goto op_semantics_36;
6573                        break;
6574                    }
6575                  break;
6576                case 0xc1:
6577                    GETBYTE ();
6578                    switch (op[3] & 0x00)
6579                    {
6580                      case 0x00:
6581                        goto op_semantics_37;
6582                        break;
6583                    }
6584                  break;
6585                case 0xc2:
6586                    GETBYTE ();
6587                    switch (op[3] & 0x00)
6588                    {
6589                      case 0x00:
6590                        goto op_semantics_38;
6591                        break;
6592                    }
6593                  break;
6594                case 0xc5:
6595                    GETBYTE ();
6596                    switch (op[3] & 0x00)
6597                    {
6598                      case 0x00:
6599                        goto op_semantics_39;
6600                        break;
6601                    }
6602                  break;
6603                case 0xc8:
6604                    GETBYTE ();
6605                    switch (op[3] & 0x00)
6606                    {
6607                      case 0x00:
6608                        goto op_semantics_40;
6609                        break;
6610                    }
6611                  break;
6612                case 0xcc:
6613                    GETBYTE ();
6614                    switch (op[3] & 0x0f)
6615                    {
6616                      case 0x00:
6617                        goto op_semantics_41;
6618                        break;
6619                      case 0x01:
6620                        goto op_semantics_42;
6621                        break;
6622                      case 0x02:
6623                        goto op_semantics_43;
6624                        break;
6625                      default: UNSUPPORTED(); break;
6626                    }
6627                  break;
6628                case 0xcd:
6629                    GETBYTE ();
6630                    switch (op[3] & 0x0f)
6631                    {
6632                      case 0x00:
6633                        goto op_semantics_44;
6634                        break;
6635                      case 0x08:
6636                        goto op_semantics_45;
6637                        break;
6638                      case 0x09:
6639                        goto op_semantics_46;
6640                        break;
6641                      case 0x0c:
6642                        goto op_semantics_47;
6643                        break;
6644                      case 0x0d:
6645                        goto op_semantics_48;
6646                        break;
6647                      default: UNSUPPORTED(); break;
6648                    }
6649                  break;
6650                case 0xd0:
6651                    GETBYTE ();
6652                    switch (op[3] & 0x00)
6653                    {
6654                      case 0x00:
6655                        goto op_semantics_36;
6656                        break;
6657                    }
6658                  break;
6659                case 0xd1:
6660                    GETBYTE ();
6661                    switch (op[3] & 0x00)
6662                    {
6663                      case 0x00:
6664                        goto op_semantics_37;
6665                        break;
6666                    }
6667                  break;
6668                case 0xd2:
6669                    GETBYTE ();
6670                    switch (op[3] & 0x00)
6671                    {
6672                      case 0x00:
6673                        goto op_semantics_38;
6674                        break;
6675                    }
6676                  break;
6677                case 0xd5:
6678                    GETBYTE ();
6679                    switch (op[3] & 0x00)
6680                    {
6681                      case 0x00:
6682                        goto op_semantics_39;
6683                        break;
6684                    }
6685                  break;
6686                case 0xd8:
6687                    GETBYTE ();
6688                    switch (op[3] & 0x00)
6689                    {
6690                      case 0x00:
6691                        goto op_semantics_40;
6692                        break;
6693                    }
6694                  break;
6695                case 0xdc:
6696                    GETBYTE ();
6697                    switch (op[3] & 0x0f)
6698                    {
6699                      case 0x00:
6700                        goto op_semantics_41;
6701                        break;
6702                      case 0x01:
6703                        goto op_semantics_42;
6704                        break;
6705                      case 0x02:
6706                        goto op_semantics_43;
6707                        break;
6708                      default: UNSUPPORTED(); break;
6709                    }
6710                  break;
6711                case 0xdd:
6712                    GETBYTE ();
6713                    switch (op[3] & 0x0f)
6714                    {
6715                      case 0x00:
6716                        goto op_semantics_44;
6717                        break;
6718                      case 0x08:
6719                        goto op_semantics_45;
6720                        break;
6721                      case 0x09:
6722                        goto op_semantics_46;
6723                        break;
6724                      case 0x0c:
6725                        goto op_semantics_47;
6726                        break;
6727                      case 0x0d:
6728                        goto op_semantics_48;
6729                        break;
6730                      default: UNSUPPORTED(); break;
6731                    }
6732                  break;
6733                case 0xe0:
6734                    GETBYTE ();
6735                    switch (op[3] & 0x00)
6736                    {
6737                      case 0x00:
6738                        goto op_semantics_36;
6739                        break;
6740                    }
6741                  break;
6742                case 0xe1:
6743                    GETBYTE ();
6744                    switch (op[3] & 0x00)
6745                    {
6746                      case 0x00:
6747                        goto op_semantics_37;
6748                        break;
6749                    }
6750                  break;
6751                case 0xe2:
6752                    GETBYTE ();
6753                    switch (op[3] & 0x00)
6754                    {
6755                      case 0x00:
6756                        goto op_semantics_38;
6757                        break;
6758                    }
6759                  break;
6760                case 0xe5:
6761                    GETBYTE ();
6762                    switch (op[3] & 0x00)
6763                    {
6764                      case 0x00:
6765                        goto op_semantics_39;
6766                        break;
6767                    }
6768                  break;
6769                case 0xe8:
6770                    GETBYTE ();
6771                    switch (op[3] & 0x00)
6772                    {
6773                      case 0x00:
6774                        goto op_semantics_40;
6775                        break;
6776                    }
6777                  break;
6778                case 0xec:
6779                    GETBYTE ();
6780                    switch (op[3] & 0x0f)
6781                    {
6782                      case 0x00:
6783                        goto op_semantics_41;
6784                        break;
6785                      case 0x01:
6786                        goto op_semantics_42;
6787                        break;
6788                      case 0x02:
6789                        goto op_semantics_43;
6790                        break;
6791                      default: UNSUPPORTED(); break;
6792                    }
6793                  break;
6794                case 0xed:
6795                    GETBYTE ();
6796                    switch (op[3] & 0x0f)
6797                    {
6798                      case 0x00:
6799                        goto op_semantics_44;
6800                        break;
6801                      case 0x08:
6802                        goto op_semantics_45;
6803                        break;
6804                      case 0x09:
6805                        goto op_semantics_46;
6806                        break;
6807                      case 0x0c:
6808                        goto op_semantics_47;
6809                        break;
6810                      case 0x0d:
6811                        goto op_semantics_48;
6812                        break;
6813                      default: UNSUPPORTED(); break;
6814                    }
6815                  break;
6816                case 0xf0:
6817                    GETBYTE ();
6818                    switch (op[3] & 0x00)
6819                    {
6820                      case 0x00:
6821                        goto op_semantics_36;
6822                        break;
6823                    }
6824                  break;
6825                case 0xf1:
6826                    GETBYTE ();
6827                    switch (op[3] & 0x00)
6828                    {
6829                      case 0x00:
6830                        goto op_semantics_37;
6831                        break;
6832                    }
6833                  break;
6834                case 0xf2:
6835                    GETBYTE ();
6836                    switch (op[3] & 0x00)
6837                    {
6838                      case 0x00:
6839                        goto op_semantics_38;
6840                        break;
6841                    }
6842                  break;
6843                case 0xf5:
6844                    GETBYTE ();
6845                    switch (op[3] & 0x00)
6846                    {
6847                      case 0x00:
6848                        goto op_semantics_39;
6849                        break;
6850                    }
6851                  break;
6852                case 0xf8:
6853                    GETBYTE ();
6854                    switch (op[3] & 0x00)
6855                    {
6856                      case 0x00:
6857                        goto op_semantics_40;
6858                        break;
6859                    }
6860                  break;
6861                case 0xfc:
6862                    GETBYTE ();
6863                    switch (op[3] & 0x0f)
6864                    {
6865                      case 0x00:
6866                        goto op_semantics_41;
6867                        break;
6868                      case 0x01:
6869                        goto op_semantics_42;
6870                        break;
6871                      case 0x02:
6872                        goto op_semantics_43;
6873                        break;
6874                      default: UNSUPPORTED(); break;
6875                    }
6876                  break;
6877                case 0xfd:
6878                    GETBYTE ();
6879                    switch (op[3] & 0x0f)
6880                    {
6881                      case 0x00:
6882                        goto op_semantics_44;
6883                        break;
6884                      case 0x08:
6885                        goto op_semantics_45;
6886                        break;
6887                      case 0x09:
6888                        goto op_semantics_46;
6889                        break;
6890                      case 0x0c:
6891                        goto op_semantics_47;
6892                        break;
6893                      case 0x0d:
6894                        goto op_semantics_48;
6895                        break;
6896                      default: UNSUPPORTED(); break;
6897                    }
6898                  break;
6899                default: UNSUPPORTED(); break;
6900              }
6901            break;
6902          default: UNSUPPORTED(); break;
6903        }
6904      break;
6905    case 0x77:
6906        GETBYTE ();
6907        switch (op[1] & 0xf0)
6908        {
6909          case 0x00:
6910            goto op_semantics_32;
6911            break;
6912          case 0x10:
6913            goto op_semantics_33;
6914            break;
6915          case 0x20:
6916            goto op_semantics_34;
6917            break;
6918          case 0x30:
6919            goto op_semantics_35;
6920            break;
6921          default: UNSUPPORTED(); break;
6922        }
6923      break;
6924    case 0x78:
6925        GETBYTE ();
6926        switch (op[1] & 0x00)
6927        {
6928          case 0x00:
6929            op_semantics_49:
6930              {
6931                /** 0111 100b ittt rdst			bset	#%1, %0 */
6932#line 968 "rx-decode.opc"
6933                int b AU = op[0] & 0x01;
6934#line 968 "rx-decode.opc"
6935                int ittt AU = (op[1] >> 4) & 0x0f;
6936#line 968 "rx-decode.opc"
6937                int rdst AU = op[1] & 0x0f;
6938                if (trace)
6939                  {
6940                    printf ("\033[33m%s\033[0m  %02x %02x\n",
6941                           "/** 0111 100b ittt rdst			bset	#%1, %0 */",
6942                           op[0], op[1]);
6943                    printf ("  b = 0x%x,", b);
6944                    printf ("  ittt = 0x%x,", ittt);
6945                    printf ("  rdst = 0x%x\n", rdst);
6946                  }
6947                SYNTAX("bset	#%1, %0");
6948#line 968 "rx-decode.opc"
6949                ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950
6951
6952              }
6953            break;
6954        }
6955      break;
6956    case 0x79:
6957        GETBYTE ();
6958        switch (op[1] & 0x00)
6959        {
6960          case 0x00:
6961            goto op_semantics_49;
6962            break;
6963        }
6964      break;
6965    case 0x7a:
6966        GETBYTE ();
6967        switch (op[1] & 0x00)
6968        {
6969          case 0x00:
6970            op_semantics_50:
6971              {
6972                /** 0111 101b ittt rdst			bclr	#%1, %0 */
6973#line 980 "rx-decode.opc"
6974                int b AU = op[0] & 0x01;
6975#line 980 "rx-decode.opc"
6976                int ittt AU = (op[1] >> 4) & 0x0f;
6977#line 980 "rx-decode.opc"
6978                int rdst AU = op[1] & 0x0f;
6979                if (trace)
6980                  {
6981                    printf ("\033[33m%s\033[0m  %02x %02x\n",
6982                           "/** 0111 101b ittt rdst			bclr	#%1, %0 */",
6983                           op[0], op[1]);
6984                    printf ("  b = 0x%x,", b);
6985                    printf ("  ittt = 0x%x,", ittt);
6986                    printf ("  rdst = 0x%x\n", rdst);
6987                  }
6988                SYNTAX("bclr	#%1, %0");
6989#line 980 "rx-decode.opc"
6990                ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991
6992
6993              }
6994            break;
6995        }
6996      break;
6997    case 0x7b:
6998        GETBYTE ();
6999        switch (op[1] & 0x00)
7000        {
7001          case 0x00:
7002            goto op_semantics_50;
7003            break;
7004        }
7005      break;
7006    case 0x7c:
7007        GETBYTE ();
7008        switch (op[1] & 0x00)
7009        {
7010          case 0x00:
7011            op_semantics_51:
7012              {
7013                /** 0111 110b ittt rdst			btst	#%2, %1 */
7014#line 992 "rx-decode.opc"
7015                int b AU = op[0] & 0x01;
7016#line 992 "rx-decode.opc"
7017                int ittt AU = (op[1] >> 4) & 0x0f;
7018#line 992 "rx-decode.opc"
7019                int rdst AU = op[1] & 0x0f;
7020                if (trace)
7021                  {
7022                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7023                           "/** 0111 110b ittt rdst			btst	#%2, %1 */",
7024                           op[0], op[1]);
7025                    printf ("  b = 0x%x,", b);
7026                    printf ("  ittt = 0x%x,", ittt);
7027                    printf ("  rdst = 0x%x\n", rdst);
7028                  }
7029                SYNTAX("btst	#%2, %1");
7030#line 992 "rx-decode.opc"
7031                ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032
7033
7034              }
7035            break;
7036        }
7037      break;
7038    case 0x7d:
7039        GETBYTE ();
7040        switch (op[1] & 0x00)
7041        {
7042          case 0x00:
7043            goto op_semantics_51;
7044            break;
7045        }
7046      break;
7047    case 0x7e:
7048        GETBYTE ();
7049        switch (op[1] & 0xf0)
7050        {
7051          case 0x00:
7052              {
7053                /** 0111 1110 0000 rdst			not	%0 */
7054#line 483 "rx-decode.opc"
7055                int rdst AU = op[1] & 0x0f;
7056                if (trace)
7057                  {
7058                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7059                           "/** 0111 1110 0000 rdst			not	%0 */",
7060                           op[0], op[1]);
7061                    printf ("  rdst = 0x%x\n", rdst);
7062                  }
7063                SYNTAX("not	%0");
7064#line 483 "rx-decode.opc"
7065                ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066
7067              }
7068            break;
7069          case 0x10:
7070              {
7071                /** 0111 1110 0001 rdst			neg	%0 */
7072#line 504 "rx-decode.opc"
7073                int rdst AU = op[1] & 0x0f;
7074                if (trace)
7075                  {
7076                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7077                           "/** 0111 1110 0001 rdst			neg	%0 */",
7078                           op[0], op[1]);
7079                    printf ("  rdst = 0x%x\n", rdst);
7080                  }
7081                SYNTAX("neg	%0");
7082#line 504 "rx-decode.opc"
7083                ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084
7085              }
7086            break;
7087          case 0x20:
7088              {
7089                /** 0111 1110 0010 rdst			abs	%0 */
7090#line 586 "rx-decode.opc"
7091                int rdst AU = op[1] & 0x0f;
7092                if (trace)
7093                  {
7094                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7095                           "/** 0111 1110 0010 rdst			abs	%0 */",
7096                           op[0], op[1]);
7097                    printf ("  rdst = 0x%x\n", rdst);
7098                  }
7099                SYNTAX("abs	%0");
7100#line 586 "rx-decode.opc"
7101                ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102
7103              }
7104            break;
7105          case 0x30:
7106              {
7107                /** 0111 1110 0011 rdst		sat	%0 */
7108#line 906 "rx-decode.opc"
7109                int rdst AU = op[1] & 0x0f;
7110                if (trace)
7111                  {
7112                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7113                           "/** 0111 1110 0011 rdst		sat	%0 */",
7114                           op[0], op[1]);
7115                    printf ("  rdst = 0x%x\n", rdst);
7116                  }
7117                SYNTAX("sat	%0");
7118#line 906 "rx-decode.opc"
7119                ID(sat); DR (rdst);
7120
7121              }
7122            break;
7123          case 0x40:
7124              {
7125                /** 0111 1110 0100 rdst			rorc	%0 */
7126#line 766 "rx-decode.opc"
7127                int rdst AU = op[1] & 0x0f;
7128                if (trace)
7129                  {
7130                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7131                           "/** 0111 1110 0100 rdst			rorc	%0 */",
7132                           op[0], op[1]);
7133                    printf ("  rdst = 0x%x\n", rdst);
7134                  }
7135                SYNTAX("rorc	%0");
7136#line 766 "rx-decode.opc"
7137                ID(rorc); DR(rdst); F__SZC;
7138
7139              }
7140            break;
7141          case 0x50:
7142              {
7143                /** 0111 1110 0101 rdst			rolc	%0 */
7144#line 763 "rx-decode.opc"
7145                int rdst AU = op[1] & 0x0f;
7146                if (trace)
7147                  {
7148                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7149                           "/** 0111 1110 0101 rdst			rolc	%0 */",
7150                           op[0], op[1]);
7151                    printf ("  rdst = 0x%x\n", rdst);
7152                  }
7153                SYNTAX("rolc	%0");
7154#line 763 "rx-decode.opc"
7155                ID(rolc); DR(rdst); F__SZC;
7156
7157              }
7158            break;
7159          case 0x80:
7160          case 0x90:
7161          case 0xa0:
7162              {
7163                /** 0111 1110 10sz rsrc		push%s	%1 */
7164#line 399 "rx-decode.opc"
7165                int sz AU = (op[1] >> 4) & 0x03;
7166#line 399 "rx-decode.opc"
7167                int rsrc AU = op[1] & 0x0f;
7168                if (trace)
7169                  {
7170                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7171                           "/** 0111 1110 10sz rsrc		push%s	%1 */",
7172                           op[0], op[1]);
7173                    printf ("  sz = 0x%x,", sz);
7174                    printf ("  rsrc = 0x%x\n", rsrc);
7175                  }
7176                SYNTAX("push%s	%1");
7177#line 399 "rx-decode.opc"
7178                ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179
7180              }
7181            break;
7182          case 0xb0:
7183              {
7184                /** 0111 1110 1011 rdst		pop	%0 */
7185#line 396 "rx-decode.opc"
7186                int rdst AU = op[1] & 0x0f;
7187                if (trace)
7188                  {
7189                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7190                           "/** 0111 1110 1011 rdst		pop	%0 */",
7191                           op[0], op[1]);
7192                    printf ("  rdst = 0x%x\n", rdst);
7193                  }
7194                SYNTAX("pop	%0");
7195#line 396 "rx-decode.opc"
7196                ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197
7198              }
7199            break;
7200          case 0xc0:
7201          case 0xd0:
7202              {
7203                /** 0111 1110 110 crsrc			pushc	%1 */
7204#line 1029 "rx-decode.opc"
7205                int crsrc AU = op[1] & 0x1f;
7206                if (trace)
7207                  {
7208                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7209                           "/** 0111 1110 110 crsrc			pushc	%1 */",
7210                           op[0], op[1]);
7211                    printf ("  crsrc = 0x%x\n", crsrc);
7212                  }
7213                SYNTAX("pushc	%1");
7214#line 1029 "rx-decode.opc"
7215                ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216
7217              }
7218            break;
7219          case 0xe0:
7220          case 0xf0:
7221              {
7222                /** 0111 1110 111 crdst			popc	%0 */
7223#line 1026 "rx-decode.opc"
7224                int crdst AU = op[1] & 0x1f;
7225                if (trace)
7226                  {
7227                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7228                           "/** 0111 1110 111 crdst			popc	%0 */",
7229                           op[0], op[1]);
7230                    printf ("  crdst = 0x%x\n", crdst);
7231                  }
7232                SYNTAX("popc	%0");
7233#line 1026 "rx-decode.opc"
7234                ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235
7236              }
7237            break;
7238          default: UNSUPPORTED(); break;
7239        }
7240      break;
7241    case 0x7f:
7242        GETBYTE ();
7243        switch (op[1] & 0xff)
7244        {
7245          case 0x00:
7246          case 0x01:
7247          case 0x02:
7248          case 0x03:
7249          case 0x04:
7250          case 0x05:
7251          case 0x06:
7252          case 0x07:
7253          case 0x08:
7254          case 0x09:
7255          case 0x0a:
7256          case 0x0b:
7257          case 0x0c:
7258          case 0x0d:
7259          case 0x0e:
7260          case 0x0f:
7261              {
7262                /** 0111 1111 0000 rsrc		jmp	%0 */
7263#line 816 "rx-decode.opc"
7264                int rsrc AU = op[1] & 0x0f;
7265                if (trace)
7266                  {
7267                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7268                           "/** 0111 1111 0000 rsrc		jmp	%0 */",
7269                           op[0], op[1]);
7270                    printf ("  rsrc = 0x%x\n", rsrc);
7271                  }
7272                SYNTAX("jmp	%0");
7273#line 816 "rx-decode.opc"
7274                ID(branch); DR(rsrc);
7275
7276              }
7277            break;
7278          case 0x10:
7279          case 0x11:
7280          case 0x12:
7281          case 0x13:
7282          case 0x14:
7283          case 0x15:
7284          case 0x16:
7285          case 0x17:
7286          case 0x18:
7287          case 0x19:
7288          case 0x1a:
7289          case 0x1b:
7290          case 0x1c:
7291          case 0x1d:
7292          case 0x1e:
7293          case 0x1f:
7294              {
7295                /** 0111 1111 0001 rsrc		jsr	%0 */
7296#line 819 "rx-decode.opc"
7297                int rsrc AU = op[1] & 0x0f;
7298                if (trace)
7299                  {
7300                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7301                           "/** 0111 1111 0001 rsrc		jsr	%0 */",
7302                           op[0], op[1]);
7303                    printf ("  rsrc = 0x%x\n", rsrc);
7304                  }
7305                SYNTAX("jsr	%0");
7306#line 819 "rx-decode.opc"
7307                ID(jsr); DR(rsrc);
7308
7309              }
7310            break;
7311          case 0x40:
7312          case 0x41:
7313          case 0x42:
7314          case 0x43:
7315          case 0x44:
7316          case 0x45:
7317          case 0x46:
7318          case 0x47:
7319          case 0x48:
7320          case 0x49:
7321          case 0x4a:
7322          case 0x4b:
7323          case 0x4c:
7324          case 0x4d:
7325          case 0x4e:
7326          case 0x4f:
7327              {
7328                /** 0111 1111 0100 rsrc		bra.l	%0 */
7329#line 812 "rx-decode.opc"
7330                int rsrc AU = op[1] & 0x0f;
7331                if (trace)
7332                  {
7333                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7334                           "/** 0111 1111 0100 rsrc		bra.l	%0 */",
7335                           op[0], op[1]);
7336                    printf ("  rsrc = 0x%x\n", rsrc);
7337                  }
7338                SYNTAX("bra.l	%0");
7339#line 812 "rx-decode.opc"
7340                ID(branchrel); DR(rsrc);
7341
7342
7343              }
7344            break;
7345          case 0x50:
7346          case 0x51:
7347          case 0x52:
7348          case 0x53:
7349          case 0x54:
7350          case 0x55:
7351          case 0x56:
7352          case 0x57:
7353          case 0x58:
7354          case 0x59:
7355          case 0x5a:
7356          case 0x5b:
7357          case 0x5c:
7358          case 0x5d:
7359          case 0x5e:
7360          case 0x5f:
7361              {
7362                /** 0111 1111 0101 rsrc		bsr.l	%0 */
7363#line 828 "rx-decode.opc"
7364                int rsrc AU = op[1] & 0x0f;
7365                if (trace)
7366                  {
7367                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7368                           "/** 0111 1111 0101 rsrc		bsr.l	%0 */",
7369                           op[0], op[1]);
7370                    printf ("  rsrc = 0x%x\n", rsrc);
7371                  }
7372                SYNTAX("bsr.l	%0");
7373#line 828 "rx-decode.opc"
7374                ID(jsrrel); DR(rsrc);
7375
7376              }
7377            break;
7378          case 0x80:
7379          case 0x81:
7380          case 0x82:
7381              {
7382                /** 0111 1111 1000 00sz		suntil%s */
7383#line 852 "rx-decode.opc"
7384                int sz AU = op[1] & 0x03;
7385                if (trace)
7386                  {
7387                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7388                           "/** 0111 1111 1000 00sz		suntil%s */",
7389                           op[0], op[1]);
7390                    printf ("  sz = 0x%x\n", sz);
7391                  }
7392                SYNTAX("suntil%s");
7393#line 852 "rx-decode.opc"
7394                ID(suntil); BWL(sz); F___ZC;
7395
7396              }
7397            break;
7398          case 0x83:
7399              {
7400                /** 0111 1111 1000 0011		scmpu */
7401                if (trace)
7402                  {
7403                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7404                           "/** 0111 1111 1000 0011		scmpu */",
7405                           op[0], op[1]);
7406                  }
7407                SYNTAX("scmpu");
7408#line 843 "rx-decode.opc"
7409                ID(scmpu); F___ZC;
7410
7411              }
7412            break;
7413          case 0x84:
7414          case 0x85:
7415          case 0x86:
7416              {
7417                /** 0111 1111 1000 01sz		swhile%s */
7418#line 855 "rx-decode.opc"
7419                int sz AU = op[1] & 0x03;
7420                if (trace)
7421                  {
7422                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7423                           "/** 0111 1111 1000 01sz		swhile%s */",
7424                           op[0], op[1]);
7425                    printf ("  sz = 0x%x\n", sz);
7426                  }
7427                SYNTAX("swhile%s");
7428#line 855 "rx-decode.opc"
7429                ID(swhile); BWL(sz); F___ZC;
7430
7431              }
7432            break;
7433          case 0x87:
7434              {
7435                /** 0111 1111 1000 0111		smovu */
7436                if (trace)
7437                  {
7438                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7439                           "/** 0111 1111 1000 0111		smovu */",
7440                           op[0], op[1]);
7441                  }
7442                SYNTAX("smovu");
7443#line 846 "rx-decode.opc"
7444                ID(smovu);
7445
7446              }
7447            break;
7448          case 0x88:
7449          case 0x89:
7450          case 0x8a:
7451              {
7452                /** 0111 1111 1000 10sz		sstr%s */
7453#line 861 "rx-decode.opc"
7454                int sz AU = op[1] & 0x03;
7455                if (trace)
7456                  {
7457                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7458                           "/** 0111 1111 1000 10sz		sstr%s */",
7459                           op[0], op[1]);
7460                    printf ("  sz = 0x%x\n", sz);
7461                  }
7462                SYNTAX("sstr%s");
7463#line 861 "rx-decode.opc"
7464                ID(sstr); BWL(sz);
7465
7466              /*----------------------------------------------------------------------*/
7467              /* RMPA									*/
7468
7469              }
7470            break;
7471          case 0x8b:
7472              {
7473                /** 0111 1111 1000 1011		smovb */
7474                if (trace)
7475                  {
7476                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7477                           "/** 0111 1111 1000 1011		smovb */",
7478                           op[0], op[1]);
7479                  }
7480                SYNTAX("smovb");
7481#line 849 "rx-decode.opc"
7482                ID(smovb);
7483
7484              }
7485            break;
7486          case 0x8c:
7487          case 0x8d:
7488          case 0x8e:
7489              {
7490                /** 0111 1111 1000 11sz		rmpa%s */
7491#line 867 "rx-decode.opc"
7492                int sz AU = op[1] & 0x03;
7493                if (trace)
7494                  {
7495                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7496                           "/** 0111 1111 1000 11sz		rmpa%s */",
7497                           op[0], op[1]);
7498                    printf ("  sz = 0x%x\n", sz);
7499                  }
7500                SYNTAX("rmpa%s");
7501#line 867 "rx-decode.opc"
7502                ID(rmpa); BWL(sz); F_OS__;
7503
7504              /*----------------------------------------------------------------------*/
7505              /* HI/LO stuff								*/
7506
7507              }
7508            break;
7509          case 0x8f:
7510              {
7511                /** 0111 1111 1000 1111		smovf */
7512                if (trace)
7513                  {
7514                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7515                           "/** 0111 1111 1000 1111		smovf */",
7516                           op[0], op[1]);
7517                  }
7518                SYNTAX("smovf");
7519#line 858 "rx-decode.opc"
7520                ID(smovf);
7521
7522              }
7523            break;
7524          case 0x93:
7525              {
7526                /** 0111 1111 1001 0011		satr */
7527                if (trace)
7528                  {
7529                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7530                           "/** 0111 1111 1001 0011		satr */",
7531                           op[0], op[1]);
7532                  }
7533                SYNTAX("satr");
7534#line 909 "rx-decode.opc"
7535                ID(satr);
7536
7537              /*----------------------------------------------------------------------*/
7538              /* FLOAT								*/
7539
7540              }
7541            break;
7542          case 0x94:
7543              {
7544                /** 0111 1111 1001 0100		rtfi */
7545                if (trace)
7546                  {
7547                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7548                           "/** 0111 1111 1001 0100		rtfi */",
7549                           op[0], op[1]);
7550                  }
7551                SYNTAX("rtfi");
7552#line 1044 "rx-decode.opc"
7553                ID(rtfi);
7554
7555              }
7556            break;
7557          case 0x95:
7558              {
7559                /** 0111 1111 1001 0101		rte */
7560                if (trace)
7561                  {
7562                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7563                           "/** 0111 1111 1001 0101		rte */",
7564                           op[0], op[1]);
7565                  }
7566                SYNTAX("rte");
7567#line 1047 "rx-decode.opc"
7568                ID(rte);
7569
7570              }
7571            break;
7572          case 0x96:
7573              {
7574                /** 0111 1111 1001 0110		wait */
7575                if (trace)
7576                  {
7577                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7578                           "/** 0111 1111 1001 0110		wait */",
7579                           op[0], op[1]);
7580                  }
7581                SYNTAX("wait");
7582#line 1059 "rx-decode.opc"
7583                ID(wait);
7584
7585              /*----------------------------------------------------------------------*/
7586              /* SCcnd								*/
7587
7588              }
7589            break;
7590          case 0xa0:
7591          case 0xa1:
7592          case 0xa2:
7593          case 0xa3:
7594          case 0xa4:
7595          case 0xa5:
7596          case 0xa6:
7597          case 0xa7:
7598          case 0xa8:
7599          case 0xa9:
7600          case 0xaa:
7601          case 0xab:
7602          case 0xac:
7603          case 0xad:
7604          case 0xae:
7605          case 0xaf:
7606              {
7607                /** 0111 1111 1010 rdst			setpsw	%0 */
7608#line 1020 "rx-decode.opc"
7609                int rdst AU = op[1] & 0x0f;
7610                if (trace)
7611                  {
7612                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7613                           "/** 0111 1111 1010 rdst			setpsw	%0 */",
7614                           op[0], op[1]);
7615                    printf ("  rdst = 0x%x\n", rdst);
7616                  }
7617                SYNTAX("setpsw	%0");
7618#line 1020 "rx-decode.opc"
7619                ID(setpsw); DF(rdst);
7620
7621              }
7622            break;
7623          case 0xb0:
7624          case 0xb1:
7625          case 0xb2:
7626          case 0xb3:
7627          case 0xb4:
7628          case 0xb5:
7629          case 0xb6:
7630          case 0xb7:
7631          case 0xb8:
7632          case 0xb9:
7633          case 0xba:
7634          case 0xbb:
7635          case 0xbc:
7636          case 0xbd:
7637          case 0xbe:
7638          case 0xbf:
7639              {
7640                /** 0111 1111 1011 rdst			clrpsw	%0 */
7641#line 1017 "rx-decode.opc"
7642                int rdst AU = op[1] & 0x0f;
7643                if (trace)
7644                  {
7645                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7646                           "/** 0111 1111 1011 rdst			clrpsw	%0 */",
7647                           op[0], op[1]);
7648                    printf ("  rdst = 0x%x\n", rdst);
7649                  }
7650                SYNTAX("clrpsw	%0");
7651#line 1017 "rx-decode.opc"
7652                ID(clrpsw); DF(rdst);
7653
7654              }
7655            break;
7656          default: UNSUPPORTED(); break;
7657        }
7658      break;
7659    case 0x80:
7660        GETBYTE ();
7661        switch (op[1] & 0x00)
7662        {
7663          case 0x00:
7664            op_semantics_52:
7665              {
7666                /** 10sz 0dsp a dst b src	mov%s	%1, %0 */
7667#line 357 "rx-decode.opc"
7668                int sz AU = (op[0] >> 4) & 0x03;
7669#line 357 "rx-decode.opc"
7670                int dsp AU = op[0] & 0x07;
7671#line 357 "rx-decode.opc"
7672                int a AU = (op[1] >> 7) & 0x01;
7673#line 357 "rx-decode.opc"
7674                int dst AU = (op[1] >> 4) & 0x07;
7675#line 357 "rx-decode.opc"
7676                int b AU = (op[1] >> 3) & 0x01;
7677#line 357 "rx-decode.opc"
7678                int src AU = op[1] & 0x07;
7679                if (trace)
7680                  {
7681                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7682                           "/** 10sz 0dsp a dst b src	mov%s	%1, %0 */",
7683                           op[0], op[1]);
7684                    printf ("  sz = 0x%x,", sz);
7685                    printf ("  dsp = 0x%x,", dsp);
7686                    printf ("  a = 0x%x,", a);
7687                    printf ("  dst = 0x%x,", dst);
7688                    printf ("  b = 0x%x,", b);
7689                    printf ("  src = 0x%x\n", src);
7690                  }
7691                SYNTAX("mov%s	%1, %0");
7692#line 357 "rx-decode.opc"
7693                ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
7694
7695              }
7696            break;
7697        }
7698      break;
7699    case 0x81:
7700        GETBYTE ();
7701        switch (op[1] & 0x00)
7702        {
7703          case 0x00:
7704            goto op_semantics_52;
7705            break;
7706        }
7707      break;
7708    case 0x82:
7709        GETBYTE ();
7710        switch (op[1] & 0x00)
7711        {
7712          case 0x00:
7713            goto op_semantics_52;
7714            break;
7715        }
7716      break;
7717    case 0x83:
7718        GETBYTE ();
7719        switch (op[1] & 0x00)
7720        {
7721          case 0x00:
7722            goto op_semantics_52;
7723            break;
7724        }
7725      break;
7726    case 0x84:
7727        GETBYTE ();
7728        switch (op[1] & 0x00)
7729        {
7730          case 0x00:
7731            goto op_semantics_52;
7732            break;
7733        }
7734      break;
7735    case 0x85:
7736        GETBYTE ();
7737        switch (op[1] & 0x00)
7738        {
7739          case 0x00:
7740            goto op_semantics_52;
7741            break;
7742        }
7743      break;
7744    case 0x86:
7745        GETBYTE ();
7746        switch (op[1] & 0x00)
7747        {
7748          case 0x00:
7749            goto op_semantics_52;
7750            break;
7751        }
7752      break;
7753    case 0x87:
7754        GETBYTE ();
7755        switch (op[1] & 0x00)
7756        {
7757          case 0x00:
7758            goto op_semantics_52;
7759            break;
7760        }
7761      break;
7762    case 0x88:
7763        GETBYTE ();
7764        switch (op[1] & 0x00)
7765        {
7766          case 0x00:
7767            op_semantics_53:
7768              {
7769                /** 10sz 1dsp a src b dst	mov%s	%1, %0 */
7770#line 354 "rx-decode.opc"
7771                int sz AU = (op[0] >> 4) & 0x03;
7772#line 354 "rx-decode.opc"
7773                int dsp AU = op[0] & 0x07;
7774#line 354 "rx-decode.opc"
7775                int a AU = (op[1] >> 7) & 0x01;
7776#line 354 "rx-decode.opc"
7777                int src AU = (op[1] >> 4) & 0x07;
7778#line 354 "rx-decode.opc"
7779                int b AU = (op[1] >> 3) & 0x01;
7780#line 354 "rx-decode.opc"
7781                int dst AU = op[1] & 0x07;
7782                if (trace)
7783                  {
7784                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7785                           "/** 10sz 1dsp a src b dst	mov%s	%1, %0 */",
7786                           op[0], op[1]);
7787                    printf ("  sz = 0x%x,", sz);
7788                    printf ("  dsp = 0x%x,", dsp);
7789                    printf ("  a = 0x%x,", a);
7790                    printf ("  src = 0x%x,", src);
7791                    printf ("  b = 0x%x,", b);
7792                    printf ("  dst = 0x%x\n", dst);
7793                  }
7794                SYNTAX("mov%s	%1, %0");
7795#line 354 "rx-decode.opc"
7796                ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
7797
7798              }
7799            break;
7800        }
7801      break;
7802    case 0x89:
7803        GETBYTE ();
7804        switch (op[1] & 0x00)
7805        {
7806          case 0x00:
7807            goto op_semantics_53;
7808            break;
7809        }
7810      break;
7811    case 0x8a:
7812        GETBYTE ();
7813        switch (op[1] & 0x00)
7814        {
7815          case 0x00:
7816            goto op_semantics_53;
7817            break;
7818        }
7819      break;
7820    case 0x8b:
7821        GETBYTE ();
7822        switch (op[1] & 0x00)
7823        {
7824          case 0x00:
7825            goto op_semantics_53;
7826            break;
7827        }
7828      break;
7829    case 0x8c:
7830        GETBYTE ();
7831        switch (op[1] & 0x00)
7832        {
7833          case 0x00:
7834            goto op_semantics_53;
7835            break;
7836        }
7837      break;
7838    case 0x8d:
7839        GETBYTE ();
7840        switch (op[1] & 0x00)
7841        {
7842          case 0x00:
7843            goto op_semantics_53;
7844            break;
7845        }
7846      break;
7847    case 0x8e:
7848        GETBYTE ();
7849        switch (op[1] & 0x00)
7850        {
7851          case 0x00:
7852            goto op_semantics_53;
7853            break;
7854        }
7855      break;
7856    case 0x8f:
7857        GETBYTE ();
7858        switch (op[1] & 0x00)
7859        {
7860          case 0x00:
7861            goto op_semantics_53;
7862            break;
7863        }
7864      break;
7865    case 0x90:
7866        GETBYTE ();
7867        switch (op[1] & 0x00)
7868        {
7869          case 0x00:
7870            goto op_semantics_52;
7871            break;
7872        }
7873      break;
7874    case 0x91:
7875        GETBYTE ();
7876        switch (op[1] & 0x00)
7877        {
7878          case 0x00:
7879            goto op_semantics_52;
7880            break;
7881        }
7882      break;
7883    case 0x92:
7884        GETBYTE ();
7885        switch (op[1] & 0x00)
7886        {
7887          case 0x00:
7888            goto op_semantics_52;
7889            break;
7890        }
7891      break;
7892    case 0x93:
7893        GETBYTE ();
7894        switch (op[1] & 0x00)
7895        {
7896          case 0x00:
7897            goto op_semantics_52;
7898            break;
7899        }
7900      break;
7901    case 0x94:
7902        GETBYTE ();
7903        switch (op[1] & 0x00)
7904        {
7905          case 0x00:
7906            goto op_semantics_52;
7907            break;
7908        }
7909      break;
7910    case 0x95:
7911        GETBYTE ();
7912        switch (op[1] & 0x00)
7913        {
7914          case 0x00:
7915            goto op_semantics_52;
7916            break;
7917        }
7918      break;
7919    case 0x96:
7920        GETBYTE ();
7921        switch (op[1] & 0x00)
7922        {
7923          case 0x00:
7924            goto op_semantics_52;
7925            break;
7926        }
7927      break;
7928    case 0x97:
7929        GETBYTE ();
7930        switch (op[1] & 0x00)
7931        {
7932          case 0x00:
7933            goto op_semantics_52;
7934            break;
7935        }
7936      break;
7937    case 0x98:
7938        GETBYTE ();
7939        switch (op[1] & 0x00)
7940        {
7941          case 0x00:
7942            goto op_semantics_53;
7943            break;
7944        }
7945      break;
7946    case 0x99:
7947        GETBYTE ();
7948        switch (op[1] & 0x00)
7949        {
7950          case 0x00:
7951            goto op_semantics_53;
7952            break;
7953        }
7954      break;
7955    case 0x9a:
7956        GETBYTE ();
7957        switch (op[1] & 0x00)
7958        {
7959          case 0x00:
7960            goto op_semantics_53;
7961            break;
7962        }
7963      break;
7964    case 0x9b:
7965        GETBYTE ();
7966        switch (op[1] & 0x00)
7967        {
7968          case 0x00:
7969            goto op_semantics_53;
7970            break;
7971        }
7972      break;
7973    case 0x9c:
7974        GETBYTE ();
7975        switch (op[1] & 0x00)
7976        {
7977          case 0x00:
7978            goto op_semantics_53;
7979            break;
7980        }
7981      break;
7982    case 0x9d:
7983        GETBYTE ();
7984        switch (op[1] & 0x00)
7985        {
7986          case 0x00:
7987            goto op_semantics_53;
7988            break;
7989        }
7990      break;
7991    case 0x9e:
7992        GETBYTE ();
7993        switch (op[1] & 0x00)
7994        {
7995          case 0x00:
7996            goto op_semantics_53;
7997            break;
7998        }
7999      break;
8000    case 0x9f:
8001        GETBYTE ();
8002        switch (op[1] & 0x00)
8003        {
8004          case 0x00:
8005            goto op_semantics_53;
8006            break;
8007        }
8008      break;
8009    case 0xa0:
8010        GETBYTE ();
8011        switch (op[1] & 0x00)
8012        {
8013          case 0x00:
8014            goto op_semantics_52;
8015            break;
8016        }
8017      break;
8018    case 0xa1:
8019        GETBYTE ();
8020        switch (op[1] & 0x00)
8021        {
8022          case 0x00:
8023            goto op_semantics_52;
8024            break;
8025        }
8026      break;
8027    case 0xa2:
8028        GETBYTE ();
8029        switch (op[1] & 0x00)
8030        {
8031          case 0x00:
8032            goto op_semantics_52;
8033            break;
8034        }
8035      break;
8036    case 0xa3:
8037        GETBYTE ();
8038        switch (op[1] & 0x00)
8039        {
8040          case 0x00:
8041            goto op_semantics_52;
8042            break;
8043        }
8044      break;
8045    case 0xa4:
8046        GETBYTE ();
8047        switch (op[1] & 0x00)
8048        {
8049          case 0x00:
8050            goto op_semantics_52;
8051            break;
8052        }
8053      break;
8054    case 0xa5:
8055        GETBYTE ();
8056        switch (op[1] & 0x00)
8057        {
8058          case 0x00:
8059            goto op_semantics_52;
8060            break;
8061        }
8062      break;
8063    case 0xa6:
8064        GETBYTE ();
8065        switch (op[1] & 0x00)
8066        {
8067          case 0x00:
8068            goto op_semantics_52;
8069            break;
8070        }
8071      break;
8072    case 0xa7:
8073        GETBYTE ();
8074        switch (op[1] & 0x00)
8075        {
8076          case 0x00:
8077            goto op_semantics_52;
8078            break;
8079        }
8080      break;
8081    case 0xa8:
8082        GETBYTE ();
8083        switch (op[1] & 0x00)
8084        {
8085          case 0x00:
8086            goto op_semantics_53;
8087            break;
8088        }
8089      break;
8090    case 0xa9:
8091        GETBYTE ();
8092        switch (op[1] & 0x00)
8093        {
8094          case 0x00:
8095            goto op_semantics_53;
8096            break;
8097        }
8098      break;
8099    case 0xaa:
8100        GETBYTE ();
8101        switch (op[1] & 0x00)
8102        {
8103          case 0x00:
8104            goto op_semantics_53;
8105            break;
8106        }
8107      break;
8108    case 0xab:
8109        GETBYTE ();
8110        switch (op[1] & 0x00)
8111        {
8112          case 0x00:
8113            goto op_semantics_53;
8114            break;
8115        }
8116      break;
8117    case 0xac:
8118        GETBYTE ();
8119        switch (op[1] & 0x00)
8120        {
8121          case 0x00:
8122            goto op_semantics_53;
8123            break;
8124        }
8125      break;
8126    case 0xad:
8127        GETBYTE ();
8128        switch (op[1] & 0x00)
8129        {
8130          case 0x00:
8131            goto op_semantics_53;
8132            break;
8133        }
8134      break;
8135    case 0xae:
8136        GETBYTE ();
8137        switch (op[1] & 0x00)
8138        {
8139          case 0x00:
8140            goto op_semantics_53;
8141            break;
8142        }
8143      break;
8144    case 0xaf:
8145        GETBYTE ();
8146        switch (op[1] & 0x00)
8147        {
8148          case 0x00:
8149            goto op_semantics_53;
8150            break;
8151        }
8152      break;
8153    case 0xb0:
8154        GETBYTE ();
8155        switch (op[1] & 0x00)
8156        {
8157          case 0x00:
8158            op_semantics_54:
8159              {
8160                /** 1011 w dsp a src b dst	movu%s	%1, %0 */
8161#line 377 "rx-decode.opc"
8162                int w AU = (op[0] >> 3) & 0x01;
8163#line 377 "rx-decode.opc"
8164                int dsp AU = op[0] & 0x07;
8165#line 377 "rx-decode.opc"
8166                int a AU = (op[1] >> 7) & 0x01;
8167#line 377 "rx-decode.opc"
8168                int src AU = (op[1] >> 4) & 0x07;
8169#line 377 "rx-decode.opc"
8170                int b AU = (op[1] >> 3) & 0x01;
8171#line 377 "rx-decode.opc"
8172                int dst AU = op[1] & 0x07;
8173                if (trace)
8174                  {
8175                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8176                           "/** 1011 w dsp a src b dst	movu%s	%1, %0 */",
8177                           op[0], op[1]);
8178                    printf ("  w = 0x%x,", w);
8179                    printf ("  dsp = 0x%x,", dsp);
8180                    printf ("  a = 0x%x,", a);
8181                    printf ("  src = 0x%x,", src);
8182                    printf ("  b = 0x%x,", b);
8183                    printf ("  dst = 0x%x\n", dst);
8184                  }
8185                SYNTAX("movu%s	%1, %0");
8186#line 377 "rx-decode.opc"
8187                ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
8188
8189              }
8190            break;
8191        }
8192      break;
8193    case 0xb1:
8194        GETBYTE ();
8195        switch (op[1] & 0x00)
8196        {
8197          case 0x00:
8198            goto op_semantics_54;
8199            break;
8200        }
8201      break;
8202    case 0xb2:
8203        GETBYTE ();
8204        switch (op[1] & 0x00)
8205        {
8206          case 0x00:
8207            goto op_semantics_54;
8208            break;
8209        }
8210      break;
8211    case 0xb3:
8212        GETBYTE ();
8213        switch (op[1] & 0x00)
8214        {
8215          case 0x00:
8216            goto op_semantics_54;
8217            break;
8218        }
8219      break;
8220    case 0xb4:
8221        GETBYTE ();
8222        switch (op[1] & 0x00)
8223        {
8224          case 0x00:
8225            goto op_semantics_54;
8226            break;
8227        }
8228      break;
8229    case 0xb5:
8230        GETBYTE ();
8231        switch (op[1] & 0x00)
8232        {
8233          case 0x00:
8234            goto op_semantics_54;
8235            break;
8236        }
8237      break;
8238    case 0xb6:
8239        GETBYTE ();
8240        switch (op[1] & 0x00)
8241        {
8242          case 0x00:
8243            goto op_semantics_54;
8244            break;
8245        }
8246      break;
8247    case 0xb7:
8248        GETBYTE ();
8249        switch (op[1] & 0x00)
8250        {
8251          case 0x00:
8252            goto op_semantics_54;
8253            break;
8254        }
8255      break;
8256    case 0xb8:
8257        GETBYTE ();
8258        switch (op[1] & 0x00)
8259        {
8260          case 0x00:
8261            goto op_semantics_54;
8262            break;
8263        }
8264      break;
8265    case 0xb9:
8266        GETBYTE ();
8267        switch (op[1] & 0x00)
8268        {
8269          case 0x00:
8270            goto op_semantics_54;
8271            break;
8272        }
8273      break;
8274    case 0xba:
8275        GETBYTE ();
8276        switch (op[1] & 0x00)
8277        {
8278          case 0x00:
8279            goto op_semantics_54;
8280            break;
8281        }
8282      break;
8283    case 0xbb:
8284        GETBYTE ();
8285        switch (op[1] & 0x00)
8286        {
8287          case 0x00:
8288            goto op_semantics_54;
8289            break;
8290        }
8291      break;
8292    case 0xbc:
8293        GETBYTE ();
8294        switch (op[1] & 0x00)
8295        {
8296          case 0x00:
8297            goto op_semantics_54;
8298            break;
8299        }
8300      break;
8301    case 0xbd:
8302        GETBYTE ();
8303        switch (op[1] & 0x00)
8304        {
8305          case 0x00:
8306            goto op_semantics_54;
8307            break;
8308        }
8309      break;
8310    case 0xbe:
8311        GETBYTE ();
8312        switch (op[1] & 0x00)
8313        {
8314          case 0x00:
8315            goto op_semantics_54;
8316            break;
8317        }
8318      break;
8319    case 0xbf:
8320        GETBYTE ();
8321        switch (op[1] & 0x00)
8322        {
8323          case 0x00:
8324            goto op_semantics_54;
8325            break;
8326        }
8327      break;
8328    case 0xc0:
8329        GETBYTE ();
8330        switch (op[1] & 0x00)
8331        {
8332          case 0x00:
8333            op_semantics_55:
8334              {
8335                /** 11sz sd ss rsrc rdst	mov%s	%1, %0 */
8336#line 335 "rx-decode.opc"
8337                int sz AU = (op[0] >> 4) & 0x03;
8338#line 335 "rx-decode.opc"
8339                int sd AU = (op[0] >> 2) & 0x03;
8340#line 335 "rx-decode.opc"
8341                int ss AU = op[0] & 0x03;
8342#line 335 "rx-decode.opc"
8343                int rsrc AU = (op[1] >> 4) & 0x0f;
8344#line 335 "rx-decode.opc"
8345                int rdst AU = op[1] & 0x0f;
8346                if (trace)
8347                  {
8348                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8349                           "/** 11sz sd ss rsrc rdst	mov%s	%1, %0 */",
8350                           op[0], op[1]);
8351                    printf ("  sz = 0x%x,", sz);
8352                    printf ("  sd = 0x%x,", sd);
8353                    printf ("  ss = 0x%x,", ss);
8354                    printf ("  rsrc = 0x%x,", rsrc);
8355                    printf ("  rdst = 0x%x\n", rdst);
8356                  }
8357                SYNTAX("mov%s	%1, %0");
8358#line 335 "rx-decode.opc"
8359                if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360                  {
8361                    ID(nop2);
8362                    SYNTAX ("nop\t; mov.l\tr0, r0");
8363                  }
8364                else
8365                  {
8366                    ID(mov); sBWL(sz); F_____;
8367                    if ((ss == 3) && (sd != 3))
8368              	{
8369              	  SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370              	}
8371                    else
8372              	{
8373              	  SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374              	}
8375                  }
8376
8377              }
8378            break;
8379        }
8380      break;
8381    case 0xc1:
8382        GETBYTE ();
8383        switch (op[1] & 0x00)
8384        {
8385          case 0x00:
8386            goto op_semantics_55;
8387            break;
8388        }
8389      break;
8390    case 0xc2:
8391        GETBYTE ();
8392        switch (op[1] & 0x00)
8393        {
8394          case 0x00:
8395            goto op_semantics_55;
8396            break;
8397        }
8398      break;
8399    case 0xc3:
8400        GETBYTE ();
8401        switch (op[1] & 0x00)
8402        {
8403          case 0x00:
8404            goto op_semantics_55;
8405            break;
8406        }
8407      break;
8408    case 0xc4:
8409        GETBYTE ();
8410        switch (op[1] & 0x00)
8411        {
8412          case 0x00:
8413            goto op_semantics_55;
8414            break;
8415        }
8416      break;
8417    case 0xc5:
8418        GETBYTE ();
8419        switch (op[1] & 0x00)
8420        {
8421          case 0x00:
8422            goto op_semantics_55;
8423            break;
8424        }
8425      break;
8426    case 0xc6:
8427        GETBYTE ();
8428        switch (op[1] & 0x00)
8429        {
8430          case 0x00:
8431            goto op_semantics_55;
8432            break;
8433        }
8434      break;
8435    case 0xc7:
8436        GETBYTE ();
8437        switch (op[1] & 0x00)
8438        {
8439          case 0x00:
8440            goto op_semantics_55;
8441            break;
8442        }
8443      break;
8444    case 0xc8:
8445        GETBYTE ();
8446        switch (op[1] & 0x00)
8447        {
8448          case 0x00:
8449            goto op_semantics_55;
8450            break;
8451        }
8452      break;
8453    case 0xc9:
8454        GETBYTE ();
8455        switch (op[1] & 0x00)
8456        {
8457          case 0x00:
8458            goto op_semantics_55;
8459            break;
8460        }
8461      break;
8462    case 0xca:
8463        GETBYTE ();
8464        switch (op[1] & 0x00)
8465        {
8466          case 0x00:
8467            goto op_semantics_55;
8468            break;
8469        }
8470      break;
8471    case 0xcb:
8472        GETBYTE ();
8473        switch (op[1] & 0x00)
8474        {
8475          case 0x00:
8476            goto op_semantics_55;
8477            break;
8478        }
8479      break;
8480    case 0xcc:
8481        GETBYTE ();
8482        switch (op[1] & 0x00)
8483        {
8484          case 0x00:
8485            goto op_semantics_55;
8486            break;
8487        }
8488      break;
8489    case 0xcd:
8490        GETBYTE ();
8491        switch (op[1] & 0x00)
8492        {
8493          case 0x00:
8494            goto op_semantics_55;
8495            break;
8496        }
8497      break;
8498    case 0xce:
8499        GETBYTE ();
8500        switch (op[1] & 0x00)
8501        {
8502          case 0x00:
8503            goto op_semantics_55;
8504            break;
8505        }
8506      break;
8507    case 0xcf:
8508        GETBYTE ();
8509        switch (op[1] & 0x00)
8510        {
8511          case 0x00:
8512            goto op_semantics_55;
8513            break;
8514        }
8515      break;
8516    case 0xd0:
8517        GETBYTE ();
8518        switch (op[1] & 0x00)
8519        {
8520          case 0x00:
8521            goto op_semantics_55;
8522            break;
8523        }
8524      break;
8525    case 0xd1:
8526        GETBYTE ();
8527        switch (op[1] & 0x00)
8528        {
8529          case 0x00:
8530            goto op_semantics_55;
8531            break;
8532        }
8533      break;
8534    case 0xd2:
8535        GETBYTE ();
8536        switch (op[1] & 0x00)
8537        {
8538          case 0x00:
8539            goto op_semantics_55;
8540            break;
8541        }
8542      break;
8543    case 0xd3:
8544        GETBYTE ();
8545        switch (op[1] & 0x00)
8546        {
8547          case 0x00:
8548            goto op_semantics_55;
8549            break;
8550        }
8551      break;
8552    case 0xd4:
8553        GETBYTE ();
8554        switch (op[1] & 0x00)
8555        {
8556          case 0x00:
8557            goto op_semantics_55;
8558            break;
8559        }
8560      break;
8561    case 0xd5:
8562        GETBYTE ();
8563        switch (op[1] & 0x00)
8564        {
8565          case 0x00:
8566            goto op_semantics_55;
8567            break;
8568        }
8569      break;
8570    case 0xd6:
8571        GETBYTE ();
8572        switch (op[1] & 0x00)
8573        {
8574          case 0x00:
8575            goto op_semantics_55;
8576            break;
8577        }
8578      break;
8579    case 0xd7:
8580        GETBYTE ();
8581        switch (op[1] & 0x00)
8582        {
8583          case 0x00:
8584            goto op_semantics_55;
8585            break;
8586        }
8587      break;
8588    case 0xd8:
8589        GETBYTE ();
8590        switch (op[1] & 0x00)
8591        {
8592          case 0x00:
8593            goto op_semantics_55;
8594            break;
8595        }
8596      break;
8597    case 0xd9:
8598        GETBYTE ();
8599        switch (op[1] & 0x00)
8600        {
8601          case 0x00:
8602            goto op_semantics_55;
8603            break;
8604        }
8605      break;
8606    case 0xda:
8607        GETBYTE ();
8608        switch (op[1] & 0x00)
8609        {
8610          case 0x00:
8611            goto op_semantics_55;
8612            break;
8613        }
8614      break;
8615    case 0xdb:
8616        GETBYTE ();
8617        switch (op[1] & 0x00)
8618        {
8619          case 0x00:
8620            goto op_semantics_55;
8621            break;
8622        }
8623      break;
8624    case 0xdc:
8625        GETBYTE ();
8626        switch (op[1] & 0x00)
8627        {
8628          case 0x00:
8629            goto op_semantics_55;
8630            break;
8631        }
8632      break;
8633    case 0xdd:
8634        GETBYTE ();
8635        switch (op[1] & 0x00)
8636        {
8637          case 0x00:
8638            goto op_semantics_55;
8639            break;
8640        }
8641      break;
8642    case 0xde:
8643        GETBYTE ();
8644        switch (op[1] & 0x00)
8645        {
8646          case 0x00:
8647            goto op_semantics_55;
8648            break;
8649        }
8650      break;
8651    case 0xdf:
8652        GETBYTE ();
8653        switch (op[1] & 0x00)
8654        {
8655          case 0x00:
8656            goto op_semantics_55;
8657            break;
8658        }
8659      break;
8660    case 0xe0:
8661        GETBYTE ();
8662        switch (op[1] & 0x00)
8663        {
8664          case 0x00:
8665            goto op_semantics_55;
8666            break;
8667        }
8668      break;
8669    case 0xe1:
8670        GETBYTE ();
8671        switch (op[1] & 0x00)
8672        {
8673          case 0x00:
8674            goto op_semantics_55;
8675            break;
8676        }
8677      break;
8678    case 0xe2:
8679        GETBYTE ();
8680        switch (op[1] & 0x00)
8681        {
8682          case 0x00:
8683            goto op_semantics_55;
8684            break;
8685        }
8686      break;
8687    case 0xe3:
8688        GETBYTE ();
8689        switch (op[1] & 0x00)
8690        {
8691          case 0x00:
8692            goto op_semantics_55;
8693            break;
8694        }
8695      break;
8696    case 0xe4:
8697        GETBYTE ();
8698        switch (op[1] & 0x00)
8699        {
8700          case 0x00:
8701            goto op_semantics_55;
8702            break;
8703        }
8704      break;
8705    case 0xe5:
8706        GETBYTE ();
8707        switch (op[1] & 0x00)
8708        {
8709          case 0x00:
8710            goto op_semantics_55;
8711            break;
8712        }
8713      break;
8714    case 0xe6:
8715        GETBYTE ();
8716        switch (op[1] & 0x00)
8717        {
8718          case 0x00:
8719            goto op_semantics_55;
8720            break;
8721        }
8722      break;
8723    case 0xe7:
8724        GETBYTE ();
8725        switch (op[1] & 0x00)
8726        {
8727          case 0x00:
8728            goto op_semantics_55;
8729            break;
8730        }
8731      break;
8732    case 0xe8:
8733        GETBYTE ();
8734        switch (op[1] & 0x00)
8735        {
8736          case 0x00:
8737            goto op_semantics_55;
8738            break;
8739        }
8740      break;
8741    case 0xe9:
8742        GETBYTE ();
8743        switch (op[1] & 0x00)
8744        {
8745          case 0x00:
8746            goto op_semantics_55;
8747            break;
8748        }
8749      break;
8750    case 0xea:
8751        GETBYTE ();
8752        switch (op[1] & 0x00)
8753        {
8754          case 0x00:
8755            goto op_semantics_55;
8756            break;
8757        }
8758      break;
8759    case 0xeb:
8760        GETBYTE ();
8761        switch (op[1] & 0x00)
8762        {
8763          case 0x00:
8764            goto op_semantics_55;
8765            break;
8766        }
8767      break;
8768    case 0xec:
8769        GETBYTE ();
8770        switch (op[1] & 0x00)
8771        {
8772          case 0x00:
8773            goto op_semantics_55;
8774            break;
8775        }
8776      break;
8777    case 0xed:
8778        GETBYTE ();
8779        switch (op[1] & 0x00)
8780        {
8781          case 0x00:
8782            goto op_semantics_55;
8783            break;
8784        }
8785      break;
8786    case 0xee:
8787        GETBYTE ();
8788        switch (op[1] & 0x00)
8789        {
8790          case 0x00:
8791            goto op_semantics_55;
8792            break;
8793        }
8794      break;
8795    case 0xef:
8796        GETBYTE ();
8797        switch (op[1] & 0x00)
8798        {
8799          case 0x00:
8800            goto op_semantics_55;
8801            break;
8802        }
8803      break;
8804    case 0xf0:
8805        GETBYTE ();
8806        switch (op[1] & 0x08)
8807        {
8808          case 0x00:
8809            op_semantics_56:
8810              {
8811                /** 1111 00sd rdst 0bit			bset	#%1, %0%S0 */
8812#line 960 "rx-decode.opc"
8813                int sd AU = op[0] & 0x03;
8814#line 960 "rx-decode.opc"
8815                int rdst AU = (op[1] >> 4) & 0x0f;
8816#line 960 "rx-decode.opc"
8817                int bit AU = op[1] & 0x07;
8818                if (trace)
8819                  {
8820                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8821                           "/** 1111 00sd rdst 0bit			bset	#%1, %0%S0 */",
8822                           op[0], op[1]);
8823                    printf ("  sd = 0x%x,", sd);
8824                    printf ("  rdst = 0x%x,", rdst);
8825                    printf ("  bit = 0x%x\n", bit);
8826                  }
8827                SYNTAX("bset	#%1, %0%S0");
8828#line 960 "rx-decode.opc"
8829                ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830
8831              }
8832            break;
8833          case 0x08:
8834            op_semantics_57:
8835              {
8836                /** 1111 00sd rdst 1bit			bclr	#%1, %0%S0 */
8837#line 972 "rx-decode.opc"
8838                int sd AU = op[0] & 0x03;
8839#line 972 "rx-decode.opc"
8840                int rdst AU = (op[1] >> 4) & 0x0f;
8841#line 972 "rx-decode.opc"
8842                int bit AU = op[1] & 0x07;
8843                if (trace)
8844                  {
8845                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8846                           "/** 1111 00sd rdst 1bit			bclr	#%1, %0%S0 */",
8847                           op[0], op[1]);
8848                    printf ("  sd = 0x%x,", sd);
8849                    printf ("  rdst = 0x%x,", rdst);
8850                    printf ("  bit = 0x%x\n", bit);
8851                  }
8852                SYNTAX("bclr	#%1, %0%S0");
8853#line 972 "rx-decode.opc"
8854                ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855
8856              }
8857            break;
8858        }
8859      break;
8860    case 0xf1:
8861        GETBYTE ();
8862        switch (op[1] & 0x08)
8863        {
8864          case 0x00:
8865            goto op_semantics_56;
8866            break;
8867          case 0x08:
8868            goto op_semantics_57;
8869            break;
8870        }
8871      break;
8872    case 0xf2:
8873        GETBYTE ();
8874        switch (op[1] & 0x08)
8875        {
8876          case 0x00:
8877            goto op_semantics_56;
8878            break;
8879          case 0x08:
8880            goto op_semantics_57;
8881            break;
8882        }
8883      break;
8884    case 0xf3:
8885        GETBYTE ();
8886        switch (op[1] & 0x08)
8887        {
8888          case 0x00:
8889            goto op_semantics_56;
8890            break;
8891          case 0x08:
8892            goto op_semantics_57;
8893            break;
8894        }
8895      break;
8896    case 0xf4:
8897        GETBYTE ();
8898        switch (op[1] & 0x0c)
8899        {
8900          case 0x00:
8901          case 0x04:
8902            op_semantics_58:
8903              {
8904                /** 1111 01sd rdst 0bit			btst	#%2, %1%S1 */
8905#line 984 "rx-decode.opc"
8906                int sd AU = op[0] & 0x03;
8907#line 984 "rx-decode.opc"
8908                int rdst AU = (op[1] >> 4) & 0x0f;
8909#line 984 "rx-decode.opc"
8910                int bit AU = op[1] & 0x07;
8911                if (trace)
8912                  {
8913                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8914                           "/** 1111 01sd rdst 0bit			btst	#%2, %1%S1 */",
8915                           op[0], op[1]);
8916                    printf ("  sd = 0x%x,", sd);
8917                    printf ("  rdst = 0x%x,", rdst);
8918                    printf ("  bit = 0x%x\n", bit);
8919                  }
8920                SYNTAX("btst	#%2, %1%S1");
8921#line 984 "rx-decode.opc"
8922                ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923
8924              }
8925            break;
8926          case 0x08:
8927            op_semantics_59:
8928              {
8929                /** 1111 01ss rsrc 10sz		push%s	%1 */
8930#line 402 "rx-decode.opc"
8931                int ss AU = op[0] & 0x03;
8932#line 402 "rx-decode.opc"
8933                int rsrc AU = (op[1] >> 4) & 0x0f;
8934#line 402 "rx-decode.opc"
8935                int sz AU = op[1] & 0x03;
8936                if (trace)
8937                  {
8938                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8939                           "/** 1111 01ss rsrc 10sz		push%s	%1 */",
8940                           op[0], op[1]);
8941                    printf ("  ss = 0x%x,", ss);
8942                    printf ("  rsrc = 0x%x,", rsrc);
8943                    printf ("  sz = 0x%x\n", sz);
8944                  }
8945                SYNTAX("push%s	%1");
8946#line 402 "rx-decode.opc"
8947                ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948
8949              /*----------------------------------------------------------------------*/
8950              /* XCHG									*/
8951
8952              }
8953            break;
8954          default: UNSUPPORTED(); break;
8955        }
8956      break;
8957    case 0xf5:
8958        GETBYTE ();
8959        switch (op[1] & 0x0c)
8960        {
8961          case 0x00:
8962          case 0x04:
8963            goto op_semantics_58;
8964            break;
8965          case 0x08:
8966            goto op_semantics_59;
8967            break;
8968          default: UNSUPPORTED(); break;
8969        }
8970      break;
8971    case 0xf6:
8972        GETBYTE ();
8973        switch (op[1] & 0x0c)
8974        {
8975          case 0x00:
8976          case 0x04:
8977            goto op_semantics_58;
8978            break;
8979          case 0x08:
8980            goto op_semantics_59;
8981            break;
8982          default: UNSUPPORTED(); break;
8983        }
8984      break;
8985    case 0xf7:
8986        GETBYTE ();
8987        switch (op[1] & 0x0c)
8988        {
8989          case 0x00:
8990          case 0x04:
8991            goto op_semantics_58;
8992            break;
8993          case 0x08:
8994            goto op_semantics_59;
8995            break;
8996          default: UNSUPPORTED(); break;
8997        }
8998      break;
8999    case 0xf8:
9000        GETBYTE ();
9001        switch (op[1] & 0x00)
9002        {
9003          case 0x00:
9004            op_semantics_60:
9005              {
9006                /** 1111 10sd rdst im sz	mov%s	#%1, %0 */
9007#line 313 "rx-decode.opc"
9008                int sd AU = op[0] & 0x03;
9009#line 313 "rx-decode.opc"
9010                int rdst AU = (op[1] >> 4) & 0x0f;
9011#line 313 "rx-decode.opc"
9012                int im AU = (op[1] >> 2) & 0x03;
9013#line 313 "rx-decode.opc"
9014                int sz AU = op[1] & 0x03;
9015                if (trace)
9016                  {
9017                    printf ("\033[33m%s\033[0m  %02x %02x\n",
9018                           "/** 1111 10sd rdst im sz	mov%s	#%1, %0 */",
9019                           op[0], op[1]);
9020                    printf ("  sd = 0x%x,", sd);
9021                    printf ("  rdst = 0x%x,", rdst);
9022                    printf ("  im = 0x%x,", im);
9023                    printf ("  sz = 0x%x\n", sz);
9024                  }
9025                SYNTAX("mov%s	#%1, %0");
9026#line 313 "rx-decode.opc"
9027                ID(mov); DD(sd, rdst, sz);
9028                if ((im == 1 && sz == 0)
9029                    || (im == 2 && sz == 1)
9030                    || (im == 0 && sz == 2))
9031                  {
9032                    BWL (sz);
9033                    SC(IMM(im));
9034                  }
9035                else
9036                  {
9037                    sBWL (sz);
9038                    SC(IMMex(im));
9039                  }
9040                 F_____;
9041
9042              }
9043            break;
9044        }
9045      break;
9046    case 0xf9:
9047        GETBYTE ();
9048        switch (op[1] & 0xff)
9049        {
9050          case 0x00:
9051          case 0x01:
9052          case 0x02:
9053          case 0x04:
9054          case 0x05:
9055          case 0x06:
9056          case 0x08:
9057          case 0x09:
9058          case 0x0a:
9059          case 0x0c:
9060          case 0x0d:
9061          case 0x0e:
9062          case 0x10:
9063          case 0x11:
9064          case 0x12:
9065          case 0x14:
9066          case 0x15:
9067          case 0x16:
9068          case 0x18:
9069          case 0x19:
9070          case 0x1a:
9071          case 0x1c:
9072          case 0x1d:
9073          case 0x1e:
9074          case 0x20:
9075          case 0x21:
9076          case 0x22:
9077          case 0x24:
9078          case 0x25:
9079          case 0x26:
9080          case 0x28:
9081          case 0x29:
9082          case 0x2a:
9083          case 0x2c:
9084          case 0x2d:
9085          case 0x2e:
9086          case 0x30:
9087          case 0x31:
9088          case 0x32:
9089          case 0x34:
9090          case 0x35:
9091          case 0x36:
9092          case 0x38:
9093          case 0x39:
9094          case 0x3a:
9095          case 0x3c:
9096          case 0x3d:
9097          case 0x3e:
9098          case 0x40:
9099          case 0x41:
9100          case 0x42:
9101          case 0x44:
9102          case 0x45:
9103          case 0x46:
9104          case 0x48:
9105          case 0x49:
9106          case 0x4a:
9107          case 0x4c:
9108          case 0x4d:
9109          case 0x4e:
9110          case 0x50:
9111          case 0x51:
9112          case 0x52:
9113          case 0x54:
9114          case 0x55:
9115          case 0x56:
9116          case 0x58:
9117          case 0x59:
9118          case 0x5a:
9119          case 0x5c:
9120          case 0x5d:
9121          case 0x5e:
9122          case 0x60:
9123          case 0x61:
9124          case 0x62:
9125          case 0x64:
9126          case 0x65:
9127          case 0x66:
9128          case 0x68:
9129          case 0x69:
9130          case 0x6a:
9131          case 0x6c:
9132          case 0x6d:
9133          case 0x6e:
9134          case 0x70:
9135          case 0x71:
9136          case 0x72:
9137          case 0x74:
9138          case 0x75:
9139          case 0x76:
9140          case 0x78:
9141          case 0x79:
9142          case 0x7a:
9143          case 0x7c:
9144          case 0x7d:
9145          case 0x7e:
9146          case 0x80:
9147          case 0x81:
9148          case 0x82:
9149          case 0x84:
9150          case 0x85:
9151          case 0x86:
9152          case 0x88:
9153          case 0x89:
9154          case 0x8a:
9155          case 0x8c:
9156          case 0x8d:
9157          case 0x8e:
9158          case 0x90:
9159          case 0x91:
9160          case 0x92:
9161          case 0x94:
9162          case 0x95:
9163          case 0x96:
9164          case 0x98:
9165          case 0x99:
9166          case 0x9a:
9167          case 0x9c:
9168          case 0x9d:
9169          case 0x9e:
9170          case 0xa0:
9171          case 0xa1:
9172          case 0xa2:
9173          case 0xa4:
9174          case 0xa5:
9175          case 0xa6:
9176          case 0xa8:
9177          case 0xa9:
9178          case 0xaa:
9179          case 0xac:
9180          case 0xad:
9181          case 0xae:
9182          case 0xb0:
9183          case 0xb1:
9184          case 0xb2:
9185          case 0xb4:
9186          case 0xb5:
9187          case 0xb6:
9188          case 0xb8:
9189          case 0xb9:
9190          case 0xba:
9191          case 0xbc:
9192          case 0xbd:
9193          case 0xbe:
9194          case 0xc0:
9195          case 0xc1:
9196          case 0xc2:
9197          case 0xc4:
9198          case 0xc5:
9199          case 0xc6:
9200          case 0xc8:
9201          case 0xc9:
9202          case 0xca:
9203          case 0xcc:
9204          case 0xcd:
9205          case 0xce:
9206          case 0xd0:
9207          case 0xd1:
9208          case 0xd2:
9209          case 0xd4:
9210          case 0xd5:
9211          case 0xd6:
9212          case 0xd8:
9213          case 0xd9:
9214          case 0xda:
9215          case 0xdc:
9216          case 0xdd:
9217          case 0xde:
9218          case 0xe0:
9219          case 0xe1:
9220          case 0xe2:
9221          case 0xe4:
9222          case 0xe5:
9223          case 0xe6:
9224          case 0xe8:
9225          case 0xe9:
9226          case 0xea:
9227          case 0xec:
9228          case 0xed:
9229          case 0xee:
9230          case 0xf0:
9231          case 0xf1:
9232          case 0xf2:
9233          case 0xf4:
9234          case 0xf5:
9235          case 0xf6:
9236          case 0xf8:
9237          case 0xf9:
9238          case 0xfa:
9239          case 0xfc:
9240          case 0xfd:
9241          case 0xfe:
9242            goto op_semantics_60;
9243            break;
9244          case 0x03:
9245              GETBYTE ();
9246              switch (op[2] & 0x0f)
9247              {
9248                case 0x00:
9249                    {
9250                      /** 1111 1001 0000 0011 rdst 0000	dmov.l	#%1, %0 */
9251#line 1211 "rx-decode.opc"
9252                      int rdst AU = (op[2] >> 4) & 0x0f;
9253                      if (trace)
9254                        {
9255                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9256                                 "/** 1111 1001 0000 0011 rdst 0000	dmov.l	#%1, %0 */",
9257                                 op[0], op[1], op[2]);
9258                          printf ("  rdst = 0x%x\n", rdst);
9259                        }
9260                      SYNTAX("dmov.l	#%1, %0");
9261#line 1211 "rx-decode.opc"
9262                      ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263
9264                    }
9265                  break;
9266                case 0x02:
9267                case 0x03:
9268                    {
9269                      /** 1111 1001 0000 0011 rdst 001s	dmov%s	#%1, %0 */
9270#line 1208 "rx-decode.opc"
9271                      int rdst AU = (op[2] >> 4) & 0x0f;
9272#line 1208 "rx-decode.opc"
9273                      int s AU = op[2] & 0x01;
9274                      if (trace)
9275                        {
9276                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9277                                 "/** 1111 1001 0000 0011 rdst 001s	dmov%s	#%1, %0 */",
9278                                 op[0], op[1], op[2]);
9279                          printf ("  rdst = 0x%x,", rdst);
9280                          printf ("  s = 0x%x\n", s);
9281                        }
9282                      SYNTAX("dmov%s	#%1, %0");
9283#line 1208 "rx-decode.opc"
9284                      ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285
9286                    }
9287                  break;
9288                default: UNSUPPORTED(); break;
9289              }
9290            break;
9291          default: UNSUPPORTED(); break;
9292        }
9293      break;
9294    case 0xfa:
9295        GETBYTE ();
9296        switch (op[1] & 0x00)
9297        {
9298          case 0x00:
9299            goto op_semantics_60;
9300            break;
9301        }
9302      break;
9303    case 0xfb:
9304        GETBYTE ();
9305        switch (op[1] & 0x00)
9306        {
9307          case 0x00:
9308            goto op_semantics_60;
9309            break;
9310        }
9311      break;
9312    case 0xfc:
9313        GETBYTE ();
9314        switch (op[1] & 0xff)
9315        {
9316          case 0x03:
9317              GETBYTE ();
9318              switch (op[2] & 0x00)
9319              {
9320                case 0x00:
9321                    {
9322                      /** 1111 1100 0000 0011 rsrc rdst	sbb	%1, %0 */
9323#line 576 "rx-decode.opc"
9324                      int rsrc AU = (op[2] >> 4) & 0x0f;
9325#line 576 "rx-decode.opc"
9326                      int rdst AU = op[2] & 0x0f;
9327                      if (trace)
9328                        {
9329                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9330                                 "/** 1111 1100 0000 0011 rsrc rdst	sbb	%1, %0 */",
9331                                 op[0], op[1], op[2]);
9332                          printf ("  rsrc = 0x%x,", rsrc);
9333                          printf ("  rdst = 0x%x\n", rdst);
9334                        }
9335                      SYNTAX("sbb	%1, %0");
9336#line 576 "rx-decode.opc"
9337                      ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338
9339                      /* FIXME: only supports .L */
9340                    }
9341                  break;
9342              }
9343            break;
9344          case 0x07:
9345              GETBYTE ();
9346              switch (op[2] & 0x00)
9347              {
9348                case 0x00:
9349                    {
9350                      /** 1111 1100 0000 0111 rsrc rdst	neg	%2, %0 */
9351#line 507 "rx-decode.opc"
9352                      int rsrc AU = (op[2] >> 4) & 0x0f;
9353#line 507 "rx-decode.opc"
9354                      int rdst AU = op[2] & 0x0f;
9355                      if (trace)
9356                        {
9357                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9358                                 "/** 1111 1100 0000 0111 rsrc rdst	neg	%2, %0 */",
9359                                 op[0], op[1], op[2]);
9360                          printf ("  rsrc = 0x%x,", rsrc);
9361                          printf ("  rdst = 0x%x\n", rdst);
9362                        }
9363                      SYNTAX("neg	%2, %0");
9364#line 507 "rx-decode.opc"
9365                      ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366
9367                    /*----------------------------------------------------------------------*/
9368                    /* ADC									*/
9369
9370                    }
9371                  break;
9372              }
9373            break;
9374          case 0x0b:
9375              GETBYTE ();
9376              switch (op[2] & 0x00)
9377              {
9378                case 0x00:
9379                    {
9380                      /** 1111 1100 0000 1011 rsrc rdst	adc	%1, %0 */
9381#line 516 "rx-decode.opc"
9382                      int rsrc AU = (op[2] >> 4) & 0x0f;
9383#line 516 "rx-decode.opc"
9384                      int rdst AU = op[2] & 0x0f;
9385                      if (trace)
9386                        {
9387                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9388                                 "/** 1111 1100 0000 1011 rsrc rdst	adc	%1, %0 */",
9389                                 op[0], op[1], op[2]);
9390                          printf ("  rsrc = 0x%x,", rsrc);
9391                          printf ("  rdst = 0x%x\n", rdst);
9392                        }
9393                      SYNTAX("adc	%1, %0");
9394#line 516 "rx-decode.opc"
9395                      ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396
9397                    }
9398                  break;
9399              }
9400            break;
9401          case 0x0f:
9402              GETBYTE ();
9403              switch (op[2] & 0x00)
9404              {
9405                case 0x00:
9406                    {
9407                      /** 1111 1100 0000 1111 rsrc rdst	abs	%1, %0 */
9408#line 589 "rx-decode.opc"
9409                      int rsrc AU = (op[2] >> 4) & 0x0f;
9410#line 589 "rx-decode.opc"
9411                      int rdst AU = op[2] & 0x0f;
9412                      if (trace)
9413                        {
9414                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9415                                 "/** 1111 1100 0000 1111 rsrc rdst	abs	%1, %0 */",
9416                                 op[0], op[1], op[2]);
9417                          printf ("  rsrc = 0x%x,", rsrc);
9418                          printf ("  rdst = 0x%x\n", rdst);
9419                        }
9420                      SYNTAX("abs	%1, %0");
9421#line 589 "rx-decode.opc"
9422                      ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423
9424                    /*----------------------------------------------------------------------*/
9425                    /* MAX									*/
9426
9427                    }
9428                  break;
9429              }
9430            break;
9431          case 0x10:
9432              GETBYTE ();
9433              switch (op[2] & 0x00)
9434              {
9435                case 0x00:
9436                  op_semantics_61:
9437                    {
9438                      /** 1111 1100 0001 00ss rsrc rdst	max	%1%S1, %0 */
9439#line 608 "rx-decode.opc"
9440                      int ss AU = op[1] & 0x03;
9441#line 608 "rx-decode.opc"
9442                      int rsrc AU = (op[2] >> 4) & 0x0f;
9443#line 608 "rx-decode.opc"
9444                      int rdst AU = op[2] & 0x0f;
9445                      if (trace)
9446                        {
9447                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9448                                 "/** 1111 1100 0001 00ss rsrc rdst	max	%1%S1, %0 */",
9449                                 op[0], op[1], op[2]);
9450                          printf ("  ss = 0x%x,", ss);
9451                          printf ("  rsrc = 0x%x,", rsrc);
9452                          printf ("  rdst = 0x%x\n", rdst);
9453                        }
9454                      SYNTAX("max	%1%S1, %0");
9455#line 608 "rx-decode.opc"
9456                      if (ss == 3 && rsrc == 0 && rdst == 0)
9457                        {
9458                          ID(nop3);
9459                          SYNTAX("nop\t; max\tr0, r0");
9460                        }
9461                      else
9462                        {
9463                          ID(max); SP(ss, rsrc); DR(rdst);
9464                        }
9465
9466                    }
9467                  break;
9468              }
9469            break;
9470          case 0x11:
9471              GETBYTE ();
9472              switch (op[2] & 0x00)
9473              {
9474                case 0x00:
9475                  goto op_semantics_61;
9476                  break;
9477              }
9478            break;
9479          case 0x12:
9480              GETBYTE ();
9481              switch (op[2] & 0x00)
9482              {
9483                case 0x00:
9484                  goto op_semantics_61;
9485                  break;
9486              }
9487            break;
9488          case 0x13:
9489              GETBYTE ();
9490              switch (op[2] & 0x00)
9491              {
9492                case 0x00:
9493                  goto op_semantics_61;
9494                  break;
9495              }
9496            break;
9497          case 0x14:
9498              GETBYTE ();
9499              switch (op[2] & 0x00)
9500              {
9501                case 0x00:
9502                  op_semantics_62:
9503                    {
9504                      /** 1111 1100 0001 01ss rsrc rdst	min	%1%S1, %0 */
9505#line 628 "rx-decode.opc"
9506                      int ss AU = op[1] & 0x03;
9507#line 628 "rx-decode.opc"
9508                      int rsrc AU = (op[2] >> 4) & 0x0f;
9509#line 628 "rx-decode.opc"
9510                      int rdst AU = op[2] & 0x0f;
9511                      if (trace)
9512                        {
9513                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9514                                 "/** 1111 1100 0001 01ss rsrc rdst	min	%1%S1, %0 */",
9515                                 op[0], op[1], op[2]);
9516                          printf ("  ss = 0x%x,", ss);
9517                          printf ("  rsrc = 0x%x,", rsrc);
9518                          printf ("  rdst = 0x%x\n", rdst);
9519                        }
9520                      SYNTAX("min	%1%S1, %0");
9521#line 628 "rx-decode.opc"
9522                      ID(min); SP(ss, rsrc); DR(rdst);
9523
9524                    }
9525                  break;
9526              }
9527            break;
9528          case 0x15:
9529              GETBYTE ();
9530              switch (op[2] & 0x00)
9531              {
9532                case 0x00:
9533                  goto op_semantics_62;
9534                  break;
9535              }
9536            break;
9537          case 0x16:
9538              GETBYTE ();
9539              switch (op[2] & 0x00)
9540              {
9541                case 0x00:
9542                  goto op_semantics_62;
9543                  break;
9544              }
9545            break;
9546          case 0x17:
9547              GETBYTE ();
9548              switch (op[2] & 0x00)
9549              {
9550                case 0x00:
9551                  goto op_semantics_62;
9552                  break;
9553              }
9554            break;
9555          case 0x18:
9556              GETBYTE ();
9557              switch (op[2] & 0x00)
9558              {
9559                case 0x00:
9560                  op_semantics_63:
9561                    {
9562                      /** 1111 1100 0001 10ss rsrc rdst	emul	%1%S1, %0 */
9563#line 686 "rx-decode.opc"
9564                      int ss AU = op[1] & 0x03;
9565#line 686 "rx-decode.opc"
9566                      int rsrc AU = (op[2] >> 4) & 0x0f;
9567#line 686 "rx-decode.opc"
9568                      int rdst AU = op[2] & 0x0f;
9569                      if (trace)
9570                        {
9571                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9572                                 "/** 1111 1100 0001 10ss rsrc rdst	emul	%1%S1, %0 */",
9573                                 op[0], op[1], op[2]);
9574                          printf ("  ss = 0x%x,", ss);
9575                          printf ("  rsrc = 0x%x,", rsrc);
9576                          printf ("  rdst = 0x%x\n", rdst);
9577                        }
9578                      SYNTAX("emul	%1%S1, %0");
9579#line 686 "rx-decode.opc"
9580                      ID(emul); SP(ss, rsrc); DR(rdst);
9581
9582                    }
9583                  break;
9584              }
9585            break;
9586          case 0x19:
9587              GETBYTE ();
9588              switch (op[2] & 0x00)
9589              {
9590                case 0x00:
9591                  goto op_semantics_63;
9592                  break;
9593              }
9594            break;
9595          case 0x1a:
9596              GETBYTE ();
9597              switch (op[2] & 0x00)
9598              {
9599                case 0x00:
9600                  goto op_semantics_63;
9601                  break;
9602              }
9603            break;
9604          case 0x1b:
9605              GETBYTE ();
9606              switch (op[2] & 0x00)
9607              {
9608                case 0x00:
9609                  goto op_semantics_63;
9610                  break;
9611              }
9612            break;
9613          case 0x1c:
9614              GETBYTE ();
9615              switch (op[2] & 0x00)
9616              {
9617                case 0x00:
9618                  op_semantics_64:
9619                    {
9620                      /** 1111 1100 0001 11ss rsrc rdst	emulu	%1%S1, %0 */
9621#line 698 "rx-decode.opc"
9622                      int ss AU = op[1] & 0x03;
9623#line 698 "rx-decode.opc"
9624                      int rsrc AU = (op[2] >> 4) & 0x0f;
9625#line 698 "rx-decode.opc"
9626                      int rdst AU = op[2] & 0x0f;
9627                      if (trace)
9628                        {
9629                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9630                                 "/** 1111 1100 0001 11ss rsrc rdst	emulu	%1%S1, %0 */",
9631                                 op[0], op[1], op[2]);
9632                          printf ("  ss = 0x%x,", ss);
9633                          printf ("  rsrc = 0x%x,", rsrc);
9634                          printf ("  rdst = 0x%x\n", rdst);
9635                        }
9636                      SYNTAX("emulu	%1%S1, %0");
9637#line 698 "rx-decode.opc"
9638                      ID(emulu); SP(ss, rsrc); DR(rdst);
9639
9640                    }
9641                  break;
9642              }
9643            break;
9644          case 0x1d:
9645              GETBYTE ();
9646              switch (op[2] & 0x00)
9647              {
9648                case 0x00:
9649                  goto op_semantics_64;
9650                  break;
9651              }
9652            break;
9653          case 0x1e:
9654              GETBYTE ();
9655              switch (op[2] & 0x00)
9656              {
9657                case 0x00:
9658                  goto op_semantics_64;
9659                  break;
9660              }
9661            break;
9662          case 0x1f:
9663              GETBYTE ();
9664              switch (op[2] & 0x00)
9665              {
9666                case 0x00:
9667                  goto op_semantics_64;
9668                  break;
9669              }
9670            break;
9671          case 0x20:
9672              GETBYTE ();
9673              switch (op[2] & 0x00)
9674              {
9675                case 0x00:
9676                  op_semantics_65:
9677                    {
9678                      /** 1111 1100 0010 00ss rsrc rdst	div	%1%S1, %0 */
9679#line 710 "rx-decode.opc"
9680                      int ss AU = op[1] & 0x03;
9681#line 710 "rx-decode.opc"
9682                      int rsrc AU = (op[2] >> 4) & 0x0f;
9683#line 710 "rx-decode.opc"
9684                      int rdst AU = op[2] & 0x0f;
9685                      if (trace)
9686                        {
9687                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9688                                 "/** 1111 1100 0010 00ss rsrc rdst	div	%1%S1, %0 */",
9689                                 op[0], op[1], op[2]);
9690                          printf ("  ss = 0x%x,", ss);
9691                          printf ("  rsrc = 0x%x,", rsrc);
9692                          printf ("  rdst = 0x%x\n", rdst);
9693                        }
9694                      SYNTAX("div	%1%S1, %0");
9695#line 710 "rx-decode.opc"
9696                      ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697
9698                    }
9699                  break;
9700              }
9701            break;
9702          case 0x21:
9703              GETBYTE ();
9704              switch (op[2] & 0x00)
9705              {
9706                case 0x00:
9707                  goto op_semantics_65;
9708                  break;
9709              }
9710            break;
9711          case 0x22:
9712              GETBYTE ();
9713              switch (op[2] & 0x00)
9714              {
9715                case 0x00:
9716                  goto op_semantics_65;
9717                  break;
9718              }
9719            break;
9720          case 0x23:
9721              GETBYTE ();
9722              switch (op[2] & 0x00)
9723              {
9724                case 0x00:
9725                  goto op_semantics_65;
9726                  break;
9727              }
9728            break;
9729          case 0x24:
9730              GETBYTE ();
9731              switch (op[2] & 0x00)
9732              {
9733                case 0x00:
9734                  op_semantics_66:
9735                    {
9736                      /** 1111 1100 0010 01ss rsrc rdst	divu	%1%S1, %0 */
9737#line 722 "rx-decode.opc"
9738                      int ss AU = op[1] & 0x03;
9739#line 722 "rx-decode.opc"
9740                      int rsrc AU = (op[2] >> 4) & 0x0f;
9741#line 722 "rx-decode.opc"
9742                      int rdst AU = op[2] & 0x0f;
9743                      if (trace)
9744                        {
9745                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9746                                 "/** 1111 1100 0010 01ss rsrc rdst	divu	%1%S1, %0 */",
9747                                 op[0], op[1], op[2]);
9748                          printf ("  ss = 0x%x,", ss);
9749                          printf ("  rsrc = 0x%x,", rsrc);
9750                          printf ("  rdst = 0x%x\n", rdst);
9751                        }
9752                      SYNTAX("divu	%1%S1, %0");
9753#line 722 "rx-decode.opc"
9754                      ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755
9756                    }
9757                  break;
9758              }
9759            break;
9760          case 0x25:
9761              GETBYTE ();
9762              switch (op[2] & 0x00)
9763              {
9764                case 0x00:
9765                  goto op_semantics_66;
9766                  break;
9767              }
9768            break;
9769          case 0x26:
9770              GETBYTE ();
9771              switch (op[2] & 0x00)
9772              {
9773                case 0x00:
9774                  goto op_semantics_66;
9775                  break;
9776              }
9777            break;
9778          case 0x27:
9779              GETBYTE ();
9780              switch (op[2] & 0x00)
9781              {
9782                case 0x00:
9783                  goto op_semantics_66;
9784                  break;
9785              }
9786            break;
9787          case 0x30:
9788              GETBYTE ();
9789              switch (op[2] & 0x00)
9790              {
9791                case 0x00:
9792                  op_semantics_67:
9793                    {
9794                      /** 1111 1100 0011 00ss rsrc rdst	tst	%1%S1, %2 */
9795#line 495 "rx-decode.opc"
9796                      int ss AU = op[1] & 0x03;
9797#line 495 "rx-decode.opc"
9798                      int rsrc AU = (op[2] >> 4) & 0x0f;
9799#line 495 "rx-decode.opc"
9800                      int rdst AU = op[2] & 0x0f;
9801                      if (trace)
9802                        {
9803                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9804                                 "/** 1111 1100 0011 00ss rsrc rdst	tst	%1%S1, %2 */",
9805                                 op[0], op[1], op[2]);
9806                          printf ("  ss = 0x%x,", ss);
9807                          printf ("  rsrc = 0x%x,", rsrc);
9808                          printf ("  rdst = 0x%x\n", rdst);
9809                        }
9810                      SYNTAX("tst	%1%S1, %2");
9811#line 495 "rx-decode.opc"
9812                      ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
9813
9814                    }
9815                  break;
9816              }
9817            break;
9818          case 0x31:
9819              GETBYTE ();
9820              switch (op[2] & 0x00)
9821              {
9822                case 0x00:
9823                  goto op_semantics_67;
9824                  break;
9825              }
9826            break;
9827          case 0x32:
9828              GETBYTE ();
9829              switch (op[2] & 0x00)
9830              {
9831                case 0x00:
9832                  goto op_semantics_67;
9833                  break;
9834              }
9835            break;
9836          case 0x33:
9837              GETBYTE ();
9838              switch (op[2] & 0x00)
9839              {
9840                case 0x00:
9841                  goto op_semantics_67;
9842                  break;
9843              }
9844            break;
9845          case 0x34:
9846              GETBYTE ();
9847              switch (op[2] & 0x00)
9848              {
9849                case 0x00:
9850                  op_semantics_68:
9851                    {
9852                      /** 1111 1100 0011 01ss rsrc rdst	xor	%1%S1, %0 */
9853#line 474 "rx-decode.opc"
9854                      int ss AU = op[1] & 0x03;
9855#line 474 "rx-decode.opc"
9856                      int rsrc AU = (op[2] >> 4) & 0x0f;
9857#line 474 "rx-decode.opc"
9858                      int rdst AU = op[2] & 0x0f;
9859                      if (trace)
9860                        {
9861                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9862                                 "/** 1111 1100 0011 01ss rsrc rdst	xor	%1%S1, %0 */",
9863                                 op[0], op[1], op[2]);
9864                          printf ("  ss = 0x%x,", ss);
9865                          printf ("  rsrc = 0x%x,", rsrc);
9866                          printf ("  rdst = 0x%x\n", rdst);
9867                        }
9868                      SYNTAX("xor	%1%S1, %0");
9869#line 474 "rx-decode.opc"
9870                      ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871
9872                    }
9873                  break;
9874              }
9875            break;
9876          case 0x35:
9877              GETBYTE ();
9878              switch (op[2] & 0x00)
9879              {
9880                case 0x00:
9881                  goto op_semantics_68;
9882                  break;
9883              }
9884            break;
9885          case 0x36:
9886              GETBYTE ();
9887              switch (op[2] & 0x00)
9888              {
9889                case 0x00:
9890                  goto op_semantics_68;
9891                  break;
9892              }
9893            break;
9894          case 0x37:
9895              GETBYTE ();
9896              switch (op[2] & 0x00)
9897              {
9898                case 0x00:
9899                  goto op_semantics_68;
9900                  break;
9901              }
9902            break;
9903          case 0x3b:
9904              GETBYTE ();
9905              switch (op[2] & 0x00)
9906              {
9907                case 0x00:
9908                    {
9909                      /** 1111 1100 0011 1011 rsrc rdst	not	%1, %0 */
9910#line 486 "rx-decode.opc"
9911                      int rsrc AU = (op[2] >> 4) & 0x0f;
9912#line 486 "rx-decode.opc"
9913                      int rdst AU = op[2] & 0x0f;
9914                      if (trace)
9915                        {
9916                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9917                                 "/** 1111 1100 0011 1011 rsrc rdst	not	%1, %0 */",
9918                                 op[0], op[1], op[2]);
9919                          printf ("  rsrc = 0x%x,", rsrc);
9920                          printf ("  rdst = 0x%x\n", rdst);
9921                        }
9922                      SYNTAX("not	%1, %0");
9923#line 486 "rx-decode.opc"
9924                      ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
9925
9926                    /*----------------------------------------------------------------------*/
9927                    /* TST									*/
9928
9929                    }
9930                  break;
9931              }
9932            break;
9933          case 0x40:
9934              GETBYTE ();
9935              switch (op[2] & 0x00)
9936              {
9937                case 0x00:
9938                  op_semantics_69:
9939                    {
9940                      /** 1111 1100 0100 00ss rsrc rdst	xchg	%1%S1, %0 */
9941#line 408 "rx-decode.opc"
9942                      int ss AU = op[1] & 0x03;
9943#line 408 "rx-decode.opc"
9944                      int rsrc AU = (op[2] >> 4) & 0x0f;
9945#line 408 "rx-decode.opc"
9946                      int rdst AU = op[2] & 0x0f;
9947                      if (trace)
9948                        {
9949                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9950                                 "/** 1111 1100 0100 00ss rsrc rdst	xchg	%1%S1, %0 */",
9951                                 op[0], op[1], op[2]);
9952                          printf ("  ss = 0x%x,", ss);
9953                          printf ("  rsrc = 0x%x,", rsrc);
9954                          printf ("  rdst = 0x%x\n", rdst);
9955                        }
9956                      SYNTAX("xchg	%1%S1, %0");
9957#line 408 "rx-decode.opc"
9958                      ID(xchg); DR(rdst); SP(ss, rsrc);
9959
9960                    }
9961                  break;
9962              }
9963            break;
9964          case 0x41:
9965              GETBYTE ();
9966              switch (op[2] & 0x00)
9967              {
9968                case 0x00:
9969                  goto op_semantics_69;
9970                  break;
9971              }
9972            break;
9973          case 0x42:
9974              GETBYTE ();
9975              switch (op[2] & 0x00)
9976              {
9977                case 0x00:
9978                  goto op_semantics_69;
9979                  break;
9980              }
9981            break;
9982          case 0x43:
9983              GETBYTE ();
9984              switch (op[2] & 0x00)
9985              {
9986                case 0x00:
9987                  goto op_semantics_69;
9988                  break;
9989              }
9990            break;
9991          case 0x44:
9992              GETBYTE ();
9993              switch (op[2] & 0x00)
9994              {
9995                case 0x00:
9996                  op_semantics_70:
9997                    {
9998                      /** 1111 1100 0100 01sd rsrc rdst	itof	%1%S1, %0 */
9999#line 951 "rx-decode.opc"
10000                      int sd AU = op[1] & 0x03;
10001#line 951 "rx-decode.opc"
10002                      int rsrc AU = (op[2] >> 4) & 0x0f;
10003#line 951 "rx-decode.opc"
10004                      int rdst AU = op[2] & 0x0f;
10005                      if (trace)
10006                        {
10007                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10008                                 "/** 1111 1100 0100 01sd rsrc rdst	itof	%1%S1, %0 */",
10009                                 op[0], op[1], op[2]);
10010                          printf ("  sd = 0x%x,", sd);
10011                          printf ("  rsrc = 0x%x,", rsrc);
10012                          printf ("  rdst = 0x%x\n", rdst);
10013                        }
10014                      SYNTAX("itof	%1%S1, %0");
10015#line 951 "rx-decode.opc"
10016                      ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10017
10018                    }
10019                  break;
10020              }
10021            break;
10022          case 0x45:
10023              GETBYTE ();
10024              switch (op[2] & 0x00)
10025              {
10026                case 0x00:
10027                  goto op_semantics_70;
10028                  break;
10029              }
10030            break;
10031          case 0x46:
10032              GETBYTE ();
10033              switch (op[2] & 0x00)
10034              {
10035                case 0x00:
10036                  goto op_semantics_70;
10037                  break;
10038              }
10039            break;
10040          case 0x47:
10041              GETBYTE ();
10042              switch (op[2] & 0x00)
10043              {
10044                case 0x00:
10045                  goto op_semantics_70;
10046                  break;
10047              }
10048            break;
10049          case 0x4b:
10050              GETBYTE ();
10051              switch (op[2] & 0x00)
10052              {
10053                case 0x00:
10054                    {
10055                      /** 1111 1100 0100 1011 rsrc rdst	stz	%1, %0 */
10056#line 1077 "rx-decode.opc"
10057                      int rsrc AU = (op[2] >> 4) & 0x0f;
10058#line 1077 "rx-decode.opc"
10059                      int rdst AU = op[2] & 0x0f;
10060                      if (trace)
10061                        {
10062                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10063                                 "/** 1111 1100 0100 1011 rsrc rdst	stz	%1, %0 */",
10064                                 op[0], op[1], op[2]);
10065                          printf ("  rsrc = 0x%x,", rsrc);
10066                          printf ("  rdst = 0x%x\n", rdst);
10067                        }
10068                      SYNTAX("stz	%1, %0");
10069#line 1077 "rx-decode.opc"
10070                      ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10071
10072                    }
10073                  break;
10074              }
10075            break;
10076          case 0x4f:
10077              GETBYTE ();
10078              switch (op[2] & 0x00)
10079              {
10080                case 0x00:
10081                    {
10082                      /** 1111 1100 0100 1111 rsrc rdst	stnz	%1, %0 */
10083#line 1080 "rx-decode.opc"
10084                      int rsrc AU = (op[2] >> 4) & 0x0f;
10085#line 1080 "rx-decode.opc"
10086                      int rdst AU = op[2] & 0x0f;
10087                      if (trace)
10088                        {
10089                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10090                                 "/** 1111 1100 0100 1111 rsrc rdst	stnz	%1, %0 */",
10091                                 op[0], op[1], op[2]);
10092                          printf ("  rsrc = 0x%x,", rsrc);
10093                          printf ("  rdst = 0x%x\n", rdst);
10094                        }
10095                      SYNTAX("stnz	%1, %0");
10096#line 1080 "rx-decode.opc"
10097                      ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
10098
10099                    }
10100                  break;
10101              }
10102            break;
10103          case 0x54:
10104              GETBYTE ();
10105              switch (op[2] & 0x00)
10106              {
10107                case 0x00:
10108                  op_semantics_71:
10109                    {
10110                      /** 1111 1100 0101 01sd rsrc rdst	utof	%1%S1, %0 */
10111#line 1137 "rx-decode.opc"
10112                      int sd AU = op[1] & 0x03;
10113#line 1137 "rx-decode.opc"
10114                      int rsrc AU = (op[2] >> 4) & 0x0f;
10115#line 1137 "rx-decode.opc"
10116                      int rdst AU = op[2] & 0x0f;
10117                      if (trace)
10118                        {
10119                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10120                                 "/** 1111 1100 0101 01sd rsrc rdst	utof	%1%S1, %0 */",
10121                                 op[0], op[1], op[2]);
10122                          printf ("  sd = 0x%x,", sd);
10123                          printf ("  rsrc = 0x%x,", rsrc);
10124                          printf ("  rdst = 0x%x\n", rdst);
10125                        }
10126                      SYNTAX("utof	%1%S1, %0");
10127#line 1137 "rx-decode.opc"
10128                      ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10129
10130                    }
10131                  break;
10132              }
10133            break;
10134          case 0x55:
10135              GETBYTE ();
10136              switch (op[2] & 0x00)
10137              {
10138                case 0x00:
10139                  goto op_semantics_71;
10140                  break;
10141              }
10142            break;
10143          case 0x56:
10144              GETBYTE ();
10145              switch (op[2] & 0x00)
10146              {
10147                case 0x00:
10148                  goto op_semantics_71;
10149                  break;
10150              }
10151            break;
10152          case 0x57:
10153              GETBYTE ();
10154              switch (op[2] & 0x00)
10155              {
10156                case 0x00:
10157                  goto op_semantics_71;
10158                  break;
10159              }
10160            break;
10161          case 0x5a:
10162              GETBYTE ();
10163              switch (op[2] & 0x00)
10164              {
10165                case 0x00:
10166                    {
10167                      /** 1111 1100 0101 1010 rsrc rdst	bfmovz	%bf */
10168#line 1152 "rx-decode.opc"
10169                      int rsrc AU = (op[2] >> 4) & 0x0f;
10170#line 1152 "rx-decode.opc"
10171                      int rdst AU = op[2] & 0x0f;
10172                      if (trace)
10173                        {
10174                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10175                                 "/** 1111 1100 0101 1010 rsrc rdst	bfmovz	%bf */",
10176                                 op[0], op[1], op[2]);
10177                          printf ("  rsrc = 0x%x,", rsrc);
10178                          printf ("  rdst = 0x%x\n", rdst);
10179                        }
10180                      SYNTAX("bfmovz	%bf");
10181#line 1152 "rx-decode.opc"
10182                      ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10183
10184                    }
10185                  break;
10186              }
10187            break;
10188          case 0x5e:
10189              GETBYTE ();
10190              switch (op[2] & 0x00)
10191              {
10192                case 0x00:
10193                    {
10194                      /** 1111 1100 0101 1110 rsrc rdst	bfmov	%bf */
10195#line 1149 "rx-decode.opc"
10196                      int rsrc AU = (op[2] >> 4) & 0x0f;
10197#line 1149 "rx-decode.opc"
10198                      int rdst AU = op[2] & 0x0f;
10199                      if (trace)
10200                        {
10201                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10202                                 "/** 1111 1100 0101 1110 rsrc rdst	bfmov	%bf */",
10203                                 op[0], op[1], op[2]);
10204                          printf ("  rsrc = 0x%x,", rsrc);
10205                          printf ("  rdst = 0x%x\n", rdst);
10206                        }
10207                      SYNTAX("bfmov	%bf");
10208#line 1149 "rx-decode.opc"
10209                      ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210
10211                    }
10212                  break;
10213              }
10214            break;
10215          case 0x60:
10216              GETBYTE ();
10217              switch (op[2] & 0x00)
10218              {
10219                case 0x00:
10220                  op_semantics_72:
10221                    {
10222                      /** 1111 1100 0110 00sd rdst rsrc	bset	%1, %0%S0 */
10223#line 963 "rx-decode.opc"
10224                      int sd AU = op[1] & 0x03;
10225#line 963 "rx-decode.opc"
10226                      int rdst AU = (op[2] >> 4) & 0x0f;
10227#line 963 "rx-decode.opc"
10228                      int rsrc AU = op[2] & 0x0f;
10229                      if (trace)
10230                        {
10231                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10232                                 "/** 1111 1100 0110 00sd rdst rsrc	bset	%1, %0%S0 */",
10233                                 op[0], op[1], op[2]);
10234                          printf ("  sd = 0x%x,", sd);
10235                          printf ("  rdst = 0x%x,", rdst);
10236                          printf ("  rsrc = 0x%x\n", rsrc);
10237                        }
10238                      SYNTAX("bset	%1, %0%S0");
10239#line 963 "rx-decode.opc"
10240                      ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241                      if (sd == 3) /* bset reg,reg */
10242                        BWL(LSIZE);
10243
10244                    }
10245                  break;
10246              }
10247            break;
10248          case 0x61:
10249              GETBYTE ();
10250              switch (op[2] & 0x00)
10251              {
10252                case 0x00:
10253                  goto op_semantics_72;
10254                  break;
10255              }
10256            break;
10257          case 0x62:
10258              GETBYTE ();
10259              switch (op[2] & 0x00)
10260              {
10261                case 0x00:
10262                  goto op_semantics_72;
10263                  break;
10264              }
10265            break;
10266          case 0x63:
10267              GETBYTE ();
10268              switch (op[2] & 0x00)
10269              {
10270                case 0x00:
10271                  goto op_semantics_72;
10272                  break;
10273              }
10274            break;
10275          case 0x64:
10276              GETBYTE ();
10277              switch (op[2] & 0x00)
10278              {
10279                case 0x00:
10280                  op_semantics_73:
10281                    {
10282                      /** 1111 1100 0110 01sd rdst rsrc	bclr	%1, %0%S0 */
10283#line 975 "rx-decode.opc"
10284                      int sd AU = op[1] & 0x03;
10285#line 975 "rx-decode.opc"
10286                      int rdst AU = (op[2] >> 4) & 0x0f;
10287#line 975 "rx-decode.opc"
10288                      int rsrc AU = op[2] & 0x0f;
10289                      if (trace)
10290                        {
10291                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10292                                 "/** 1111 1100 0110 01sd rdst rsrc	bclr	%1, %0%S0 */",
10293                                 op[0], op[1], op[2]);
10294                          printf ("  sd = 0x%x,", sd);
10295                          printf ("  rdst = 0x%x,", rdst);
10296                          printf ("  rsrc = 0x%x\n", rsrc);
10297                        }
10298                      SYNTAX("bclr	%1, %0%S0");
10299#line 975 "rx-decode.opc"
10300                      ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301                      if (sd == 3) /* bset reg,reg */
10302                        BWL(LSIZE);
10303
10304                    }
10305                  break;
10306              }
10307            break;
10308          case 0x65:
10309              GETBYTE ();
10310              switch (op[2] & 0x00)
10311              {
10312                case 0x00:
10313                  goto op_semantics_73;
10314                  break;
10315              }
10316            break;
10317          case 0x66:
10318              GETBYTE ();
10319              switch (op[2] & 0x00)
10320              {
10321                case 0x00:
10322                  goto op_semantics_73;
10323                  break;
10324              }
10325            break;
10326          case 0x67:
10327              GETBYTE ();
10328              switch (op[2] & 0x00)
10329              {
10330                case 0x00:
10331                  goto op_semantics_73;
10332                  break;
10333              }
10334            break;
10335          case 0x68:
10336              GETBYTE ();
10337              switch (op[2] & 0x00)
10338              {
10339                case 0x00:
10340                  op_semantics_74:
10341                    {
10342                      /** 1111 1100 0110 10sd rdst rsrc	btst	%2, %1%S1 */
10343#line 987 "rx-decode.opc"
10344                      int sd AU = op[1] & 0x03;
10345#line 987 "rx-decode.opc"
10346                      int rdst AU = (op[2] >> 4) & 0x0f;
10347#line 987 "rx-decode.opc"
10348                      int rsrc AU = op[2] & 0x0f;
10349                      if (trace)
10350                        {
10351                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10352                                 "/** 1111 1100 0110 10sd rdst rsrc	btst	%2, %1%S1 */",
10353                                 op[0], op[1], op[2]);
10354                          printf ("  sd = 0x%x,", sd);
10355                          printf ("  rdst = 0x%x,", rdst);
10356                          printf ("  rsrc = 0x%x\n", rsrc);
10357                        }
10358                      SYNTAX("btst	%2, %1%S1");
10359#line 987 "rx-decode.opc"
10360                      ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361                      if (sd == 3) /* bset reg,reg */
10362                        BWL(LSIZE);
10363
10364                    }
10365                  break;
10366              }
10367            break;
10368          case 0x69:
10369              GETBYTE ();
10370              switch (op[2] & 0x00)
10371              {
10372                case 0x00:
10373                  goto op_semantics_74;
10374                  break;
10375              }
10376            break;
10377          case 0x6a:
10378              GETBYTE ();
10379              switch (op[2] & 0x00)
10380              {
10381                case 0x00:
10382                  goto op_semantics_74;
10383                  break;
10384              }
10385            break;
10386          case 0x6b:
10387              GETBYTE ();
10388              switch (op[2] & 0x00)
10389              {
10390                case 0x00:
10391                  goto op_semantics_74;
10392                  break;
10393              }
10394            break;
10395          case 0x6c:
10396              GETBYTE ();
10397              switch (op[2] & 0x00)
10398              {
10399                case 0x00:
10400                  op_semantics_75:
10401                    {
10402                      /** 1111 1100 0110 11sd rdst rsrc	bnot	%1, %0%S0 */
10403#line 999 "rx-decode.opc"
10404                      int sd AU = op[1] & 0x03;
10405#line 999 "rx-decode.opc"
10406                      int rdst AU = (op[2] >> 4) & 0x0f;
10407#line 999 "rx-decode.opc"
10408                      int rsrc AU = op[2] & 0x0f;
10409                      if (trace)
10410                        {
10411                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10412                                 "/** 1111 1100 0110 11sd rdst rsrc	bnot	%1, %0%S0 */",
10413                                 op[0], op[1], op[2]);
10414                          printf ("  sd = 0x%x,", sd);
10415                          printf ("  rdst = 0x%x,", rdst);
10416                          printf ("  rsrc = 0x%x\n", rsrc);
10417                        }
10418                      SYNTAX("bnot	%1, %0%S0");
10419#line 999 "rx-decode.opc"
10420                      ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421                      if (sd == 3) /* bset reg,reg */
10422                        BWL(LSIZE);
10423
10424                    }
10425                  break;
10426              }
10427            break;
10428          case 0x6d:
10429              GETBYTE ();
10430              switch (op[2] & 0x00)
10431              {
10432                case 0x00:
10433                  goto op_semantics_75;
10434                  break;
10435              }
10436            break;
10437          case 0x6e:
10438              GETBYTE ();
10439              switch (op[2] & 0x00)
10440              {
10441                case 0x00:
10442                  goto op_semantics_75;
10443                  break;
10444              }
10445            break;
10446          case 0x6f:
10447              GETBYTE ();
10448              switch (op[2] & 0x00)
10449              {
10450                case 0x00:
10451                  goto op_semantics_75;
10452                  break;
10453              }
10454            break;
10455          case 0x78:
10456              GETBYTE ();
10457              switch (op[2] & 0x0f)
10458              {
10459                case 0x08:
10460                  op_semantics_76:
10461                    {
10462                      /** 1111 1100 0111 10sz rdst 1000	dmov.d	%1, %0 */
10463#line 1185 "rx-decode.opc"
10464                      int sz AU = op[1] & 0x03;
10465#line 1185 "rx-decode.opc"
10466                      int rdst AU = (op[2] >> 4) & 0x0f;
10467                      if (trace)
10468                        {
10469                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10470                                 "/** 1111 1100 0111 10sz rdst 1000	dmov.d	%1, %0 */",
10471                                 op[0], op[1], op[2]);
10472                          printf ("  sz = 0x%x,", sz);
10473                          printf ("  rdst = 0x%x\n", rdst);
10474                        }
10475                      SYNTAX("dmov.d	%1, %0");
10476#line 1185 "rx-decode.opc"
10477                      int rsrc;
10478                      rx_disp(0, sz, rdst, RX_Double, ld);
10479                      rsrc = GETBYTE();
10480                      if (rsrc & 0x0f)
10481                        UNSUPPORTED();
10482                      else {
10483                        ID(dmov); SDR(rsrc >> 4); F_____;
10484                      }
10485
10486                    }
10487                  break;
10488                default: UNSUPPORTED(); break;
10489              }
10490            break;
10491          case 0x79:
10492              GETBYTE ();
10493              switch (op[2] & 0x0f)
10494              {
10495                case 0x08:
10496                  goto op_semantics_76;
10497                  break;
10498                default: UNSUPPORTED(); break;
10499              }
10500            break;
10501          case 0x7a:
10502              GETBYTE ();
10503              switch (op[2] & 0x0f)
10504              {
10505                case 0x08:
10506                  goto op_semantics_76;
10507                  break;
10508                default: UNSUPPORTED(); break;
10509              }
10510            break;
10511          case 0x80:
10512              GETBYTE ();
10513              switch (op[2] & 0x00)
10514              {
10515                case 0x00:
10516                  op_semantics_77:
10517                    {
10518                      /** 1111 1100 1000 00sd rsrc rdst	fsub	%1%S1, %0 */
10519#line 930 "rx-decode.opc"
10520                      int sd AU = op[1] & 0x03;
10521#line 930 "rx-decode.opc"
10522                      int rsrc AU = (op[2] >> 4) & 0x0f;
10523#line 930 "rx-decode.opc"
10524                      int rdst AU = op[2] & 0x0f;
10525                      if (trace)
10526                        {
10527                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10528                                 "/** 1111 1100 1000 00sd rsrc rdst	fsub	%1%S1, %0 */",
10529                                 op[0], op[1], op[2]);
10530                          printf ("  sd = 0x%x,", sd);
10531                          printf ("  rsrc = 0x%x,", rsrc);
10532                          printf ("  rdst = 0x%x\n", rdst);
10533                        }
10534                      SYNTAX("fsub	%1%S1, %0");
10535#line 930 "rx-decode.opc"
10536                      ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10537
10538                    }
10539                  break;
10540              }
10541            break;
10542          case 0x81:
10543              GETBYTE ();
10544              switch (op[2] & 0x00)
10545              {
10546                case 0x00:
10547                  goto op_semantics_77;
10548                  break;
10549              }
10550            break;
10551          case 0x82:
10552              GETBYTE ();
10553              switch (op[2] & 0x00)
10554              {
10555                case 0x00:
10556                  goto op_semantics_77;
10557                  break;
10558              }
10559            break;
10560          case 0x83:
10561              GETBYTE ();
10562              switch (op[2] & 0x00)
10563              {
10564                case 0x00:
10565                  goto op_semantics_77;
10566                  break;
10567              }
10568            break;
10569          case 0x84:
10570              GETBYTE ();
10571              switch (op[2] & 0x00)
10572              {
10573                case 0x00:
10574                  op_semantics_78:
10575                    {
10576                      /** 1111 1100 1000 01sd rsrc rdst	fcmp	%1%S1, %0 */
10577#line 924 "rx-decode.opc"
10578                      int sd AU = op[1] & 0x03;
10579#line 924 "rx-decode.opc"
10580                      int rsrc AU = (op[2] >> 4) & 0x0f;
10581#line 924 "rx-decode.opc"
10582                      int rdst AU = op[2] & 0x0f;
10583                      if (trace)
10584                        {
10585                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10586                                 "/** 1111 1100 1000 01sd rsrc rdst	fcmp	%1%S1, %0 */",
10587                                 op[0], op[1], op[2]);
10588                          printf ("  sd = 0x%x,", sd);
10589                          printf ("  rsrc = 0x%x,", rsrc);
10590                          printf ("  rdst = 0x%x\n", rdst);
10591                        }
10592                      SYNTAX("fcmp	%1%S1, %0");
10593#line 924 "rx-decode.opc"
10594                      ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
10595
10596                    }
10597                  break;
10598              }
10599            break;
10600          case 0x85:
10601              GETBYTE ();
10602              switch (op[2] & 0x00)
10603              {
10604                case 0x00:
10605                  goto op_semantics_78;
10606                  break;
10607              }
10608            break;
10609          case 0x86:
10610              GETBYTE ();
10611              switch (op[2] & 0x00)
10612              {
10613                case 0x00:
10614                  goto op_semantics_78;
10615                  break;
10616              }
10617            break;
10618          case 0x87:
10619              GETBYTE ();
10620              switch (op[2] & 0x00)
10621              {
10622                case 0x00:
10623                  goto op_semantics_78;
10624                  break;
10625              }
10626            break;
10627          case 0x88:
10628              GETBYTE ();
10629              switch (op[2] & 0x00)
10630              {
10631                case 0x00:
10632                  op_semantics_79:
10633                    {
10634                      /** 1111 1100 1000 10sd rsrc rdst	fadd	%1%S1, %0 */
10635#line 918 "rx-decode.opc"
10636                      int sd AU = op[1] & 0x03;
10637#line 918 "rx-decode.opc"
10638                      int rsrc AU = (op[2] >> 4) & 0x0f;
10639#line 918 "rx-decode.opc"
10640                      int rdst AU = op[2] & 0x0f;
10641                      if (trace)
10642                        {
10643                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10644                                 "/** 1111 1100 1000 10sd rsrc rdst	fadd	%1%S1, %0 */",
10645                                 op[0], op[1], op[2]);
10646                          printf ("  sd = 0x%x,", sd);
10647                          printf ("  rsrc = 0x%x,", rsrc);
10648                          printf ("  rdst = 0x%x\n", rdst);
10649                        }
10650                      SYNTAX("fadd	%1%S1, %0");
10651#line 918 "rx-decode.opc"
10652                      ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10653
10654                    }
10655                  break;
10656              }
10657            break;
10658          case 0x89:
10659              GETBYTE ();
10660              switch (op[2] & 0x00)
10661              {
10662                case 0x00:
10663                  goto op_semantics_79;
10664                  break;
10665              }
10666            break;
10667          case 0x8a:
10668              GETBYTE ();
10669              switch (op[2] & 0x00)
10670              {
10671                case 0x00:
10672                  goto op_semantics_79;
10673                  break;
10674              }
10675            break;
10676          case 0x8b:
10677              GETBYTE ();
10678              switch (op[2] & 0x00)
10679              {
10680                case 0x00:
10681                  goto op_semantics_79;
10682                  break;
10683              }
10684            break;
10685          case 0x8c:
10686              GETBYTE ();
10687              switch (op[2] & 0x00)
10688              {
10689                case 0x00:
10690                  op_semantics_80:
10691                    {
10692                      /** 1111 1100 1000 11sd rsrc rdst	fmul	%1%S1, %0 */
10693#line 939 "rx-decode.opc"
10694                      int sd AU = op[1] & 0x03;
10695#line 939 "rx-decode.opc"
10696                      int rsrc AU = (op[2] >> 4) & 0x0f;
10697#line 939 "rx-decode.opc"
10698                      int rdst AU = op[2] & 0x0f;
10699                      if (trace)
10700                        {
10701                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10702                                 "/** 1111 1100 1000 11sd rsrc rdst	fmul	%1%S1, %0 */",
10703                                 op[0], op[1], op[2]);
10704                          printf ("  sd = 0x%x,", sd);
10705                          printf ("  rsrc = 0x%x,", rsrc);
10706                          printf ("  rdst = 0x%x\n", rdst);
10707                        }
10708                      SYNTAX("fmul	%1%S1, %0");
10709#line 939 "rx-decode.opc"
10710                      ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10711
10712                    }
10713                  break;
10714              }
10715            break;
10716          case 0x8d:
10717              GETBYTE ();
10718              switch (op[2] & 0x00)
10719              {
10720                case 0x00:
10721                  goto op_semantics_80;
10722                  break;
10723              }
10724            break;
10725          case 0x8e:
10726              GETBYTE ();
10727              switch (op[2] & 0x00)
10728              {
10729                case 0x00:
10730                  goto op_semantics_80;
10731                  break;
10732              }
10733            break;
10734          case 0x8f:
10735              GETBYTE ();
10736              switch (op[2] & 0x00)
10737              {
10738                case 0x00:
10739                  goto op_semantics_80;
10740                  break;
10741              }
10742            break;
10743          case 0x90:
10744              GETBYTE ();
10745              switch (op[2] & 0x00)
10746              {
10747                case 0x00:
10748                  op_semantics_81:
10749                    {
10750                      /** 1111 1100 1001 00sd rsrc rdst	fdiv	%1%S1, %0 */
10751#line 945 "rx-decode.opc"
10752                      int sd AU = op[1] & 0x03;
10753#line 945 "rx-decode.opc"
10754                      int rsrc AU = (op[2] >> 4) & 0x0f;
10755#line 945 "rx-decode.opc"
10756                      int rdst AU = op[2] & 0x0f;
10757                      if (trace)
10758                        {
10759                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10760                                 "/** 1111 1100 1001 00sd rsrc rdst	fdiv	%1%S1, %0 */",
10761                                 op[0], op[1], op[2]);
10762                          printf ("  sd = 0x%x,", sd);
10763                          printf ("  rsrc = 0x%x,", rsrc);
10764                          printf ("  rdst = 0x%x\n", rdst);
10765                        }
10766                      SYNTAX("fdiv	%1%S1, %0");
10767#line 945 "rx-decode.opc"
10768                      ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10769
10770                    }
10771                  break;
10772              }
10773            break;
10774          case 0x91:
10775              GETBYTE ();
10776              switch (op[2] & 0x00)
10777              {
10778                case 0x00:
10779                  goto op_semantics_81;
10780                  break;
10781              }
10782            break;
10783          case 0x92:
10784              GETBYTE ();
10785              switch (op[2] & 0x00)
10786              {
10787                case 0x00:
10788                  goto op_semantics_81;
10789                  break;
10790              }
10791            break;
10792          case 0x93:
10793              GETBYTE ();
10794              switch (op[2] & 0x00)
10795              {
10796                case 0x00:
10797                  goto op_semantics_81;
10798                  break;
10799              }
10800            break;
10801          case 0x94:
10802              GETBYTE ();
10803              switch (op[2] & 0x00)
10804              {
10805                case 0x00:
10806                  op_semantics_82:
10807                    {
10808                      /** 1111 1100 1001 01sd rsrc rdst	ftoi	%1%S1, %0 */
10809#line 933 "rx-decode.opc"
10810                      int sd AU = op[1] & 0x03;
10811#line 933 "rx-decode.opc"
10812                      int rsrc AU = (op[2] >> 4) & 0x0f;
10813#line 933 "rx-decode.opc"
10814                      int rdst AU = op[2] & 0x0f;
10815                      if (trace)
10816                        {
10817                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10818                                 "/** 1111 1100 1001 01sd rsrc rdst	ftoi	%1%S1, %0 */",
10819                                 op[0], op[1], op[2]);
10820                          printf ("  sd = 0x%x,", sd);
10821                          printf ("  rsrc = 0x%x,", rsrc);
10822                          printf ("  rdst = 0x%x\n", rdst);
10823                        }
10824                      SYNTAX("ftoi	%1%S1, %0");
10825#line 933 "rx-decode.opc"
10826                      ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10827
10828                    }
10829                  break;
10830              }
10831            break;
10832          case 0x95:
10833              GETBYTE ();
10834              switch (op[2] & 0x00)
10835              {
10836                case 0x00:
10837                  goto op_semantics_82;
10838                  break;
10839              }
10840            break;
10841          case 0x96:
10842              GETBYTE ();
10843              switch (op[2] & 0x00)
10844              {
10845                case 0x00:
10846                  goto op_semantics_82;
10847                  break;
10848              }
10849            break;
10850          case 0x97:
10851              GETBYTE ();
10852              switch (op[2] & 0x00)
10853              {
10854                case 0x00:
10855                  goto op_semantics_82;
10856                  break;
10857              }
10858            break;
10859          case 0x98:
10860              GETBYTE ();
10861              switch (op[2] & 0x00)
10862              {
10863                case 0x00:
10864                  op_semantics_83:
10865                    {
10866                      /** 1111 1100 1001 10sd rsrc rdst	round	%1%S1, %0 */
10867#line 948 "rx-decode.opc"
10868                      int sd AU = op[1] & 0x03;
10869#line 948 "rx-decode.opc"
10870                      int rsrc AU = (op[2] >> 4) & 0x0f;
10871#line 948 "rx-decode.opc"
10872                      int rdst AU = op[2] & 0x0f;
10873                      if (trace)
10874                        {
10875                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10876                                 "/** 1111 1100 1001 10sd rsrc rdst	round	%1%S1, %0 */",
10877                                 op[0], op[1], op[2]);
10878                          printf ("  sd = 0x%x,", sd);
10879                          printf ("  rsrc = 0x%x,", rsrc);
10880                          printf ("  rdst = 0x%x\n", rdst);
10881                        }
10882                      SYNTAX("round	%1%S1, %0");
10883#line 948 "rx-decode.opc"
10884                      ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10885
10886                    }
10887                  break;
10888              }
10889            break;
10890          case 0x99:
10891              GETBYTE ();
10892              switch (op[2] & 0x00)
10893              {
10894                case 0x00:
10895                  goto op_semantics_83;
10896                  break;
10897              }
10898            break;
10899          case 0x9a:
10900              GETBYTE ();
10901              switch (op[2] & 0x00)
10902              {
10903                case 0x00:
10904                  goto op_semantics_83;
10905                  break;
10906              }
10907            break;
10908          case 0x9b:
10909              GETBYTE ();
10910              switch (op[2] & 0x00)
10911              {
10912                case 0x00:
10913                  goto op_semantics_83;
10914                  break;
10915              }
10916            break;
10917          case 0xa0:
10918              GETBYTE ();
10919              switch (op[2] & 0x00)
10920              {
10921                case 0x00:
10922                  op_semantics_84:
10923                    {
10924                      /** 1111 1100 1010 00sd rsrc rdst	fsqrt	%1%S1, %0 */
10925#line 1131 "rx-decode.opc"
10926                      int sd AU = op[1] & 0x03;
10927#line 1131 "rx-decode.opc"
10928                      int rsrc AU = (op[2] >> 4) & 0x0f;
10929#line 1131 "rx-decode.opc"
10930                      int rdst AU = op[2] & 0x0f;
10931                      if (trace)
10932                        {
10933                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10934                                 "/** 1111 1100 1010 00sd rsrc rdst	fsqrt	%1%S1, %0 */",
10935                                 op[0], op[1], op[2]);
10936                          printf ("  sd = 0x%x,", sd);
10937                          printf ("  rsrc = 0x%x,", rsrc);
10938                          printf ("  rdst = 0x%x\n", rdst);
10939                        }
10940                      SYNTAX("fsqrt	%1%S1, %0");
10941#line 1131 "rx-decode.opc"
10942                      ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10943
10944                    }
10945                  break;
10946              }
10947            break;
10948          case 0xa1:
10949              GETBYTE ();
10950              switch (op[2] & 0x00)
10951              {
10952                case 0x00:
10953                  goto op_semantics_84;
10954                  break;
10955              }
10956            break;
10957          case 0xa2:
10958              GETBYTE ();
10959              switch (op[2] & 0x00)
10960              {
10961                case 0x00:
10962                  goto op_semantics_84;
10963                  break;
10964              }
10965            break;
10966          case 0xa3:
10967              GETBYTE ();
10968              switch (op[2] & 0x00)
10969              {
10970                case 0x00:
10971                  goto op_semantics_84;
10972                  break;
10973              }
10974            break;
10975          case 0xa4:
10976              GETBYTE ();
10977              switch (op[2] & 0x00)
10978              {
10979                case 0x00:
10980                  op_semantics_85:
10981                    {
10982                      /** 1111 1100 1010 01sd rsrc rdst	ftou	%1%S1, %0 */
10983#line 1134 "rx-decode.opc"
10984                      int sd AU = op[1] & 0x03;
10985#line 1134 "rx-decode.opc"
10986                      int rsrc AU = (op[2] >> 4) & 0x0f;
10987#line 1134 "rx-decode.opc"
10988                      int rdst AU = op[2] & 0x0f;
10989                      if (trace)
10990                        {
10991                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10992                                 "/** 1111 1100 1010 01sd rsrc rdst	ftou	%1%S1, %0 */",
10993                                 op[0], op[1], op[2]);
10994                          printf ("  sd = 0x%x,", sd);
10995                          printf ("  rsrc = 0x%x,", rsrc);
10996                          printf ("  rdst = 0x%x\n", rdst);
10997                        }
10998                      SYNTAX("ftou	%1%S1, %0");
10999#line 1134 "rx-decode.opc"
11000                      ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11001
11002                    }
11003                  break;
11004              }
11005            break;
11006          case 0xa5:
11007              GETBYTE ();
11008              switch (op[2] & 0x00)
11009              {
11010                case 0x00:
11011                  goto op_semantics_85;
11012                  break;
11013              }
11014            break;
11015          case 0xa6:
11016              GETBYTE ();
11017              switch (op[2] & 0x00)
11018              {
11019                case 0x00:
11020                  goto op_semantics_85;
11021                  break;
11022              }
11023            break;
11024          case 0xa7:
11025              GETBYTE ();
11026              switch (op[2] & 0x00)
11027              {
11028                case 0x00:
11029                  goto op_semantics_85;
11030                  break;
11031              }
11032            break;
11033          case 0xc8:
11034              GETBYTE ();
11035              switch (op[2] & 0x0f)
11036              {
11037                case 0x08:
11038                  op_semantics_86:
11039                    {
11040                      /** 1111 1100 1100 10sz rsrc 1000	dmov.d	%1, %0 */
11041#line 1198 "rx-decode.opc"
11042                      int sz AU = op[1] & 0x03;
11043#line 1198 "rx-decode.opc"
11044                      int rsrc AU = (op[2] >> 4) & 0x0f;
11045                      if (trace)
11046                        {
11047                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11048                                 "/** 1111 1100 1100 10sz rsrc 1000	dmov.d	%1, %0 */",
11049                                 op[0], op[1], op[2]);
11050                          printf ("  sz = 0x%x,", sz);
11051                          printf ("  rsrc = 0x%x\n", rsrc);
11052                        }
11053                      SYNTAX("dmov.d	%1, %0");
11054#line 1198 "rx-decode.opc"
11055                      int rdst;
11056                      rx_disp(1, sz, rsrc, RX_Double, ld);
11057                      rdst = GETBYTE();
11058                      if (rdst & 0x0f)
11059                        UNSUPPORTED();
11060                      else {
11061                        ID(dmov); DDR(rdst >> 4); F_____;
11062                      }
11063
11064                    }
11065                  break;
11066                default: UNSUPPORTED(); break;
11067              }
11068            break;
11069          case 0xc9:
11070              GETBYTE ();
11071              switch (op[2] & 0x0f)
11072              {
11073                case 0x08:
11074                  goto op_semantics_86;
11075                  break;
11076                default: UNSUPPORTED(); break;
11077              }
11078            break;
11079          case 0xca:
11080              GETBYTE ();
11081              switch (op[2] & 0x0f)
11082              {
11083                case 0x08:
11084                  goto op_semantics_86;
11085                  break;
11086                default: UNSUPPORTED(); break;
11087              }
11088            break;
11089          case 0xd0:
11090              GETBYTE ();
11091              switch (op[2] & 0x00)
11092              {
11093                case 0x00:
11094                  op_semantics_87:
11095                    {
11096                      /** 1111 1100 1101 sz sd rdst cond	sc%1%s	%0 */
11097#line 1065 "rx-decode.opc"
11098                      int sz AU = (op[1] >> 2) & 0x03;
11099#line 1065 "rx-decode.opc"
11100                      int sd AU = op[1] & 0x03;
11101#line 1065 "rx-decode.opc"
11102                      int rdst AU = (op[2] >> 4) & 0x0f;
11103#line 1065 "rx-decode.opc"
11104                      int cond AU = op[2] & 0x0f;
11105                      if (trace)
11106                        {
11107                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11108                                 "/** 1111 1100 1101 sz sd rdst cond	sc%1%s	%0 */",
11109                                 op[0], op[1], op[2]);
11110                          printf ("  sz = 0x%x,", sz);
11111                          printf ("  sd = 0x%x,", sd);
11112                          printf ("  rdst = 0x%x,", rdst);
11113                          printf ("  cond = 0x%x\n", cond);
11114                        }
11115                      SYNTAX("sc%1%s	%0");
11116#line 1065 "rx-decode.opc"
11117                      ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118
11119                    /*----------------------------------------------------------------------*/
11120                    /* RXv2 enhanced							*/
11121
11122                    }
11123                  break;
11124              }
11125            break;
11126          case 0xd1:
11127              GETBYTE ();
11128              switch (op[2] & 0x00)
11129              {
11130                case 0x00:
11131                  goto op_semantics_87;
11132                  break;
11133              }
11134            break;
11135          case 0xd2:
11136              GETBYTE ();
11137              switch (op[2] & 0x00)
11138              {
11139                case 0x00:
11140                  goto op_semantics_87;
11141                  break;
11142              }
11143            break;
11144          case 0xd3:
11145              GETBYTE ();
11146              switch (op[2] & 0x00)
11147              {
11148                case 0x00:
11149                  goto op_semantics_87;
11150                  break;
11151              }
11152            break;
11153          case 0xd4:
11154              GETBYTE ();
11155              switch (op[2] & 0x00)
11156              {
11157                case 0x00:
11158                  goto op_semantics_87;
11159                  break;
11160              }
11161            break;
11162          case 0xd5:
11163              GETBYTE ();
11164              switch (op[2] & 0x00)
11165              {
11166                case 0x00:
11167                  goto op_semantics_87;
11168                  break;
11169              }
11170            break;
11171          case 0xd6:
11172              GETBYTE ();
11173              switch (op[2] & 0x00)
11174              {
11175                case 0x00:
11176                  goto op_semantics_87;
11177                  break;
11178              }
11179            break;
11180          case 0xd7:
11181              GETBYTE ();
11182              switch (op[2] & 0x00)
11183              {
11184                case 0x00:
11185                  goto op_semantics_87;
11186                  break;
11187              }
11188            break;
11189          case 0xd8:
11190              GETBYTE ();
11191              switch (op[2] & 0x00)
11192              {
11193                case 0x00:
11194                  goto op_semantics_87;
11195                  break;
11196              }
11197            break;
11198          case 0xd9:
11199              GETBYTE ();
11200              switch (op[2] & 0x00)
11201              {
11202                case 0x00:
11203                  goto op_semantics_87;
11204                  break;
11205              }
11206            break;
11207          case 0xda:
11208              GETBYTE ();
11209              switch (op[2] & 0x00)
11210              {
11211                case 0x00:
11212                  goto op_semantics_87;
11213                  break;
11214              }
11215            break;
11216          case 0xdb:
11217              GETBYTE ();
11218              switch (op[2] & 0x00)
11219              {
11220                case 0x00:
11221                  goto op_semantics_87;
11222                  break;
11223              }
11224            break;
11225          case 0xe0:
11226              GETBYTE ();
11227              switch (op[2] & 0x0f)
11228              {
11229                case 0x00:
11230                case 0x01:
11231                case 0x02:
11232                case 0x03:
11233                case 0x04:
11234                case 0x05:
11235                case 0x06:
11236                case 0x07:
11237                case 0x08:
11238                case 0x09:
11239                case 0x0a:
11240                case 0x0b:
11241                case 0x0c:
11242                case 0x0d:
11243                case 0x0e:
11244                  op_semantics_88:
11245                    {
11246                      /** 1111 1100 111bit sd rdst cond	bm%2	#%1, %0%S0 */
11247#line 1008 "rx-decode.opc"
11248                      int bit AU = (op[1] >> 2) & 0x07;
11249#line 1008 "rx-decode.opc"
11250                      int sd AU = op[1] & 0x03;
11251#line 1008 "rx-decode.opc"
11252                      int rdst AU = (op[2] >> 4) & 0x0f;
11253#line 1008 "rx-decode.opc"
11254                      int cond AU = op[2] & 0x0f;
11255                      if (trace)
11256                        {
11257                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11258                                 "/** 1111 1100 111bit sd rdst cond	bm%2	#%1, %0%S0 */",
11259                                 op[0], op[1], op[2]);
11260                          printf ("  bit = 0x%x,", bit);
11261                          printf ("  sd = 0x%x,", sd);
11262                          printf ("  rdst = 0x%x,", rdst);
11263                          printf ("  cond = 0x%x\n", cond);
11264                        }
11265                      SYNTAX("bm%2	#%1, %0%S0");
11266#line 1008 "rx-decode.opc"
11267                      ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268
11269                    }
11270                  break;
11271                case 0x0f:
11272                  op_semantics_89:
11273                    {
11274                      /** 1111 1100 111bit sd rdst 1111	bnot	#%1, %0%S0 */
11275#line 996 "rx-decode.opc"
11276                      int bit AU = (op[1] >> 2) & 0x07;
11277#line 996 "rx-decode.opc"
11278                      int sd AU = op[1] & 0x03;
11279#line 996 "rx-decode.opc"
11280                      int rdst AU = (op[2] >> 4) & 0x0f;
11281                      if (trace)
11282                        {
11283                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11284                                 "/** 1111 1100 111bit sd rdst 1111	bnot	#%1, %0%S0 */",
11285                                 op[0], op[1], op[2]);
11286                          printf ("  bit = 0x%x,", bit);
11287                          printf ("  sd = 0x%x,", sd);
11288                          printf ("  rdst = 0x%x\n", rdst);
11289                        }
11290                      SYNTAX("bnot	#%1, %0%S0");
11291#line 996 "rx-decode.opc"
11292                      ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
11293
11294                    }
11295                  break;
11296              }
11297            break;
11298          case 0xe1:
11299              GETBYTE ();
11300              switch (op[2] & 0x0f)
11301              {
11302                case 0x00:
11303                case 0x01:
11304                case 0x02:
11305                case 0x03:
11306                case 0x04:
11307                case 0x05:
11308                case 0x06:
11309                case 0x07:
11310                case 0x08:
11311                case 0x09:
11312                case 0x0a:
11313                case 0x0b:
11314                case 0x0c:
11315                case 0x0d:
11316                case 0x0e:
11317                  goto op_semantics_88;
11318                  break;
11319                case 0x0f:
11320                  goto op_semantics_89;
11321                  break;
11322              }
11323            break;
11324          case 0xe2:
11325              GETBYTE ();
11326              switch (op[2] & 0x0f)
11327              {
11328                case 0x00:
11329                case 0x01:
11330                case 0x02:
11331                case 0x03:
11332                case 0x04:
11333                case 0x05:
11334                case 0x06:
11335                case 0x07:
11336                case 0x08:
11337                case 0x09:
11338                case 0x0a:
11339                case 0x0b:
11340                case 0x0c:
11341                case 0x0d:
11342                case 0x0e:
11343                  goto op_semantics_88;
11344                  break;
11345                case 0x0f:
11346                  goto op_semantics_89;
11347                  break;
11348              }
11349            break;
11350          case 0xe3:
11351              GETBYTE ();
11352              switch (op[2] & 0x0f)
11353              {
11354                case 0x00:
11355                case 0x01:
11356                case 0x02:
11357                case 0x03:
11358                case 0x04:
11359                case 0x05:
11360                case 0x06:
11361                case 0x07:
11362                case 0x08:
11363                case 0x09:
11364                case 0x0a:
11365                case 0x0b:
11366                case 0x0c:
11367                case 0x0d:
11368                case 0x0e:
11369                  goto op_semantics_88;
11370                  break;
11371                case 0x0f:
11372                  goto op_semantics_89;
11373                  break;
11374              }
11375            break;
11376          case 0xe4:
11377              GETBYTE ();
11378              switch (op[2] & 0x0f)
11379              {
11380                case 0x00:
11381                case 0x01:
11382                case 0x02:
11383                case 0x03:
11384                case 0x04:
11385                case 0x05:
11386                case 0x06:
11387                case 0x07:
11388                case 0x08:
11389                case 0x09:
11390                case 0x0a:
11391                case 0x0b:
11392                case 0x0c:
11393                case 0x0d:
11394                case 0x0e:
11395                  goto op_semantics_88;
11396                  break;
11397                case 0x0f:
11398                  goto op_semantics_89;
11399                  break;
11400              }
11401            break;
11402          case 0xe5:
11403              GETBYTE ();
11404              switch (op[2] & 0x0f)
11405              {
11406                case 0x00:
11407                case 0x01:
11408                case 0x02:
11409                case 0x03:
11410                case 0x04:
11411                case 0x05:
11412                case 0x06:
11413                case 0x07:
11414                case 0x08:
11415                case 0x09:
11416                case 0x0a:
11417                case 0x0b:
11418                case 0x0c:
11419                case 0x0d:
11420                case 0x0e:
11421                  goto op_semantics_88;
11422                  break;
11423                case 0x0f:
11424                  goto op_semantics_89;
11425                  break;
11426              }
11427            break;
11428          case 0xe6:
11429              GETBYTE ();
11430              switch (op[2] & 0x0f)
11431              {
11432                case 0x00:
11433                case 0x01:
11434                case 0x02:
11435                case 0x03:
11436                case 0x04:
11437                case 0x05:
11438                case 0x06:
11439                case 0x07:
11440                case 0x08:
11441                case 0x09:
11442                case 0x0a:
11443                case 0x0b:
11444                case 0x0c:
11445                case 0x0d:
11446                case 0x0e:
11447                  goto op_semantics_88;
11448                  break;
11449                case 0x0f:
11450                  goto op_semantics_89;
11451                  break;
11452              }
11453            break;
11454          case 0xe7:
11455              GETBYTE ();
11456              switch (op[2] & 0x0f)
11457              {
11458                case 0x00:
11459                case 0x01:
11460                case 0x02:
11461                case 0x03:
11462                case 0x04:
11463                case 0x05:
11464                case 0x06:
11465                case 0x07:
11466                case 0x08:
11467                case 0x09:
11468                case 0x0a:
11469                case 0x0b:
11470                case 0x0c:
11471                case 0x0d:
11472                case 0x0e:
11473                  goto op_semantics_88;
11474                  break;
11475                case 0x0f:
11476                  goto op_semantics_89;
11477                  break;
11478              }
11479            break;
11480          case 0xe8:
11481              GETBYTE ();
11482              switch (op[2] & 0x0f)
11483              {
11484                case 0x00:
11485                case 0x01:
11486                case 0x02:
11487                case 0x03:
11488                case 0x04:
11489                case 0x05:
11490                case 0x06:
11491                case 0x07:
11492                case 0x08:
11493                case 0x09:
11494                case 0x0a:
11495                case 0x0b:
11496                case 0x0c:
11497                case 0x0d:
11498                case 0x0e:
11499                  goto op_semantics_88;
11500                  break;
11501                case 0x0f:
11502                  goto op_semantics_89;
11503                  break;
11504              }
11505            break;
11506          case 0xe9:
11507              GETBYTE ();
11508              switch (op[2] & 0x0f)
11509              {
11510                case 0x00:
11511                case 0x01:
11512                case 0x02:
11513                case 0x03:
11514                case 0x04:
11515                case 0x05:
11516                case 0x06:
11517                case 0x07:
11518                case 0x08:
11519                case 0x09:
11520                case 0x0a:
11521                case 0x0b:
11522                case 0x0c:
11523                case 0x0d:
11524                case 0x0e:
11525                  goto op_semantics_88;
11526                  break;
11527                case 0x0f:
11528                  goto op_semantics_89;
11529                  break;
11530              }
11531            break;
11532          case 0xea:
11533              GETBYTE ();
11534              switch (op[2] & 0x0f)
11535              {
11536                case 0x00:
11537                case 0x01:
11538                case 0x02:
11539                case 0x03:
11540                case 0x04:
11541                case 0x05:
11542                case 0x06:
11543                case 0x07:
11544                case 0x08:
11545                case 0x09:
11546                case 0x0a:
11547                case 0x0b:
11548                case 0x0c:
11549                case 0x0d:
11550                case 0x0e:
11551                  goto op_semantics_88;
11552                  break;
11553                case 0x0f:
11554                  goto op_semantics_89;
11555                  break;
11556              }
11557            break;
11558          case 0xeb:
11559              GETBYTE ();
11560              switch (op[2] & 0x0f)
11561              {
11562                case 0x00:
11563                case 0x01:
11564                case 0x02:
11565                case 0x03:
11566                case 0x04:
11567                case 0x05:
11568                case 0x06:
11569                case 0x07:
11570                case 0x08:
11571                case 0x09:
11572                case 0x0a:
11573                case 0x0b:
11574                case 0x0c:
11575                case 0x0d:
11576                case 0x0e:
11577                  goto op_semantics_88;
11578                  break;
11579                case 0x0f:
11580                  goto op_semantics_89;
11581                  break;
11582              }
11583            break;
11584          case 0xec:
11585              GETBYTE ();
11586              switch (op[2] & 0x0f)
11587              {
11588                case 0x00:
11589                case 0x01:
11590                case 0x02:
11591                case 0x03:
11592                case 0x04:
11593                case 0x05:
11594                case 0x06:
11595                case 0x07:
11596                case 0x08:
11597                case 0x09:
11598                case 0x0a:
11599                case 0x0b:
11600                case 0x0c:
11601                case 0x0d:
11602                case 0x0e:
11603                  goto op_semantics_88;
11604                  break;
11605                case 0x0f:
11606                  goto op_semantics_89;
11607                  break;
11608              }
11609            break;
11610          case 0xed:
11611              GETBYTE ();
11612              switch (op[2] & 0x0f)
11613              {
11614                case 0x00:
11615                case 0x01:
11616                case 0x02:
11617                case 0x03:
11618                case 0x04:
11619                case 0x05:
11620                case 0x06:
11621                case 0x07:
11622                case 0x08:
11623                case 0x09:
11624                case 0x0a:
11625                case 0x0b:
11626                case 0x0c:
11627                case 0x0d:
11628                case 0x0e:
11629                  goto op_semantics_88;
11630                  break;
11631                case 0x0f:
11632                  goto op_semantics_89;
11633                  break;
11634              }
11635            break;
11636          case 0xee:
11637              GETBYTE ();
11638              switch (op[2] & 0x0f)
11639              {
11640                case 0x00:
11641                case 0x01:
11642                case 0x02:
11643                case 0x03:
11644                case 0x04:
11645                case 0x05:
11646                case 0x06:
11647                case 0x07:
11648                case 0x08:
11649                case 0x09:
11650                case 0x0a:
11651                case 0x0b:
11652                case 0x0c:
11653                case 0x0d:
11654                case 0x0e:
11655                  goto op_semantics_88;
11656                  break;
11657                case 0x0f:
11658                  goto op_semantics_89;
11659                  break;
11660              }
11661            break;
11662          case 0xef:
11663              GETBYTE ();
11664              switch (op[2] & 0x0f)
11665              {
11666                case 0x00:
11667                case 0x01:
11668                case 0x02:
11669                case 0x03:
11670                case 0x04:
11671                case 0x05:
11672                case 0x06:
11673                case 0x07:
11674                case 0x08:
11675                case 0x09:
11676                case 0x0a:
11677                case 0x0b:
11678                case 0x0c:
11679                case 0x0d:
11680                case 0x0e:
11681                  goto op_semantics_88;
11682                  break;
11683                case 0x0f:
11684                  goto op_semantics_89;
11685                  break;
11686              }
11687            break;
11688          case 0xf0:
11689              GETBYTE ();
11690              switch (op[2] & 0x0f)
11691              {
11692                case 0x00:
11693                case 0x01:
11694                case 0x02:
11695                case 0x03:
11696                case 0x04:
11697                case 0x05:
11698                case 0x06:
11699                case 0x07:
11700                case 0x08:
11701                case 0x09:
11702                case 0x0a:
11703                case 0x0b:
11704                case 0x0c:
11705                case 0x0d:
11706                case 0x0e:
11707                  goto op_semantics_88;
11708                  break;
11709                case 0x0f:
11710                  goto op_semantics_89;
11711                  break;
11712              }
11713            break;
11714          case 0xf1:
11715              GETBYTE ();
11716              switch (op[2] & 0x0f)
11717              {
11718                case 0x00:
11719                case 0x01:
11720                case 0x02:
11721                case 0x03:
11722                case 0x04:
11723                case 0x05:
11724                case 0x06:
11725                case 0x07:
11726                case 0x08:
11727                case 0x09:
11728                case 0x0a:
11729                case 0x0b:
11730                case 0x0c:
11731                case 0x0d:
11732                case 0x0e:
11733                  goto op_semantics_88;
11734                  break;
11735                case 0x0f:
11736                  goto op_semantics_89;
11737                  break;
11738              }
11739            break;
11740          case 0xf2:
11741              GETBYTE ();
11742              switch (op[2] & 0x0f)
11743              {
11744                case 0x00:
11745                case 0x01:
11746                case 0x02:
11747                case 0x03:
11748                case 0x04:
11749                case 0x05:
11750                case 0x06:
11751                case 0x07:
11752                case 0x08:
11753                case 0x09:
11754                case 0x0a:
11755                case 0x0b:
11756                case 0x0c:
11757                case 0x0d:
11758                case 0x0e:
11759                  goto op_semantics_88;
11760                  break;
11761                case 0x0f:
11762                  goto op_semantics_89;
11763                  break;
11764              }
11765            break;
11766          case 0xf3:
11767              GETBYTE ();
11768              switch (op[2] & 0x0f)
11769              {
11770                case 0x00:
11771                case 0x01:
11772                case 0x02:
11773                case 0x03:
11774                case 0x04:
11775                case 0x05:
11776                case 0x06:
11777                case 0x07:
11778                case 0x08:
11779                case 0x09:
11780                case 0x0a:
11781                case 0x0b:
11782                case 0x0c:
11783                case 0x0d:
11784                case 0x0e:
11785                  goto op_semantics_88;
11786                  break;
11787                case 0x0f:
11788                  goto op_semantics_89;
11789                  break;
11790              }
11791            break;
11792          case 0xf4:
11793              GETBYTE ();
11794              switch (op[2] & 0x0f)
11795              {
11796                case 0x00:
11797                case 0x01:
11798                case 0x02:
11799                case 0x03:
11800                case 0x04:
11801                case 0x05:
11802                case 0x06:
11803                case 0x07:
11804                case 0x08:
11805                case 0x09:
11806                case 0x0a:
11807                case 0x0b:
11808                case 0x0c:
11809                case 0x0d:
11810                case 0x0e:
11811                  goto op_semantics_88;
11812                  break;
11813                case 0x0f:
11814                  goto op_semantics_89;
11815                  break;
11816              }
11817            break;
11818          case 0xf5:
11819              GETBYTE ();
11820              switch (op[2] & 0x0f)
11821              {
11822                case 0x00:
11823                case 0x01:
11824                case 0x02:
11825                case 0x03:
11826                case 0x04:
11827                case 0x05:
11828                case 0x06:
11829                case 0x07:
11830                case 0x08:
11831                case 0x09:
11832                case 0x0a:
11833                case 0x0b:
11834                case 0x0c:
11835                case 0x0d:
11836                case 0x0e:
11837                  goto op_semantics_88;
11838                  break;
11839                case 0x0f:
11840                  goto op_semantics_89;
11841                  break;
11842              }
11843            break;
11844          case 0xf6:
11845              GETBYTE ();
11846              switch (op[2] & 0x0f)
11847              {
11848                case 0x00:
11849                case 0x01:
11850                case 0x02:
11851                case 0x03:
11852                case 0x04:
11853                case 0x05:
11854                case 0x06:
11855                case 0x07:
11856                case 0x08:
11857                case 0x09:
11858                case 0x0a:
11859                case 0x0b:
11860                case 0x0c:
11861                case 0x0d:
11862                case 0x0e:
11863                  goto op_semantics_88;
11864                  break;
11865                case 0x0f:
11866                  goto op_semantics_89;
11867                  break;
11868              }
11869            break;
11870          case 0xf7:
11871              GETBYTE ();
11872              switch (op[2] & 0x0f)
11873              {
11874                case 0x00:
11875                case 0x01:
11876                case 0x02:
11877                case 0x03:
11878                case 0x04:
11879                case 0x05:
11880                case 0x06:
11881                case 0x07:
11882                case 0x08:
11883                case 0x09:
11884                case 0x0a:
11885                case 0x0b:
11886                case 0x0c:
11887                case 0x0d:
11888                case 0x0e:
11889                  goto op_semantics_88;
11890                  break;
11891                case 0x0f:
11892                  goto op_semantics_89;
11893                  break;
11894              }
11895            break;
11896          case 0xf8:
11897              GETBYTE ();
11898              switch (op[2] & 0x0f)
11899              {
11900                case 0x00:
11901                case 0x01:
11902                case 0x02:
11903                case 0x03:
11904                case 0x04:
11905                case 0x05:
11906                case 0x06:
11907                case 0x07:
11908                case 0x08:
11909                case 0x09:
11910                case 0x0a:
11911                case 0x0b:
11912                case 0x0c:
11913                case 0x0d:
11914                case 0x0e:
11915                  goto op_semantics_88;
11916                  break;
11917                case 0x0f:
11918                  goto op_semantics_89;
11919                  break;
11920              }
11921            break;
11922          case 0xf9:
11923              GETBYTE ();
11924              switch (op[2] & 0x0f)
11925              {
11926                case 0x00:
11927                case 0x01:
11928                case 0x02:
11929                case 0x03:
11930                case 0x04:
11931                case 0x05:
11932                case 0x06:
11933                case 0x07:
11934                case 0x08:
11935                case 0x09:
11936                case 0x0a:
11937                case 0x0b:
11938                case 0x0c:
11939                case 0x0d:
11940                case 0x0e:
11941                  goto op_semantics_88;
11942                  break;
11943                case 0x0f:
11944                  goto op_semantics_89;
11945                  break;
11946              }
11947            break;
11948          case 0xfa:
11949              GETBYTE ();
11950              switch (op[2] & 0x0f)
11951              {
11952                case 0x00:
11953                case 0x01:
11954                case 0x02:
11955                case 0x03:
11956                case 0x04:
11957                case 0x05:
11958                case 0x06:
11959                case 0x07:
11960                case 0x08:
11961                case 0x09:
11962                case 0x0a:
11963                case 0x0b:
11964                case 0x0c:
11965                case 0x0d:
11966                case 0x0e:
11967                  goto op_semantics_88;
11968                  break;
11969                case 0x0f:
11970                  goto op_semantics_89;
11971                  break;
11972              }
11973            break;
11974          case 0xfb:
11975              GETBYTE ();
11976              switch (op[2] & 0x0f)
11977              {
11978                case 0x00:
11979                case 0x01:
11980                case 0x02:
11981                case 0x03:
11982                case 0x04:
11983                case 0x05:
11984                case 0x06:
11985                case 0x07:
11986                case 0x08:
11987                case 0x09:
11988                case 0x0a:
11989                case 0x0b:
11990                case 0x0c:
11991                case 0x0d:
11992                case 0x0e:
11993                  goto op_semantics_88;
11994                  break;
11995                case 0x0f:
11996                  goto op_semantics_89;
11997                  break;
11998              }
11999            break;
12000          case 0xfc:
12001              GETBYTE ();
12002              switch (op[2] & 0x0f)
12003              {
12004                case 0x00:
12005                case 0x01:
12006                case 0x02:
12007                case 0x03:
12008                case 0x04:
12009                case 0x05:
12010                case 0x06:
12011                case 0x07:
12012                case 0x08:
12013                case 0x09:
12014                case 0x0a:
12015                case 0x0b:
12016                case 0x0c:
12017                case 0x0d:
12018                case 0x0e:
12019                  goto op_semantics_88;
12020                  break;
12021                case 0x0f:
12022                  goto op_semantics_89;
12023                  break;
12024              }
12025            break;
12026          case 0xfd:
12027              GETBYTE ();
12028              switch (op[2] & 0x0f)
12029              {
12030                case 0x00:
12031                case 0x01:
12032                case 0x02:
12033                case 0x03:
12034                case 0x04:
12035                case 0x05:
12036                case 0x06:
12037                case 0x07:
12038                case 0x08:
12039                case 0x09:
12040                case 0x0a:
12041                case 0x0b:
12042                case 0x0c:
12043                case 0x0d:
12044                case 0x0e:
12045                  goto op_semantics_88;
12046                  break;
12047                case 0x0f:
12048                  goto op_semantics_89;
12049                  break;
12050              }
12051            break;
12052          case 0xfe:
12053              GETBYTE ();
12054              switch (op[2] & 0x0f)
12055              {
12056                case 0x00:
12057                case 0x01:
12058                case 0x02:
12059                case 0x03:
12060                case 0x04:
12061                case 0x05:
12062                case 0x06:
12063                case 0x07:
12064                case 0x08:
12065                case 0x09:
12066                case 0x0a:
12067                case 0x0b:
12068                case 0x0c:
12069                case 0x0d:
12070                case 0x0e:
12071                  goto op_semantics_88;
12072                  break;
12073                case 0x0f:
12074                  goto op_semantics_89;
12075                  break;
12076              }
12077            break;
12078          case 0xff:
12079              GETBYTE ();
12080              switch (op[2] & 0x0f)
12081              {
12082                case 0x00:
12083                case 0x01:
12084                case 0x02:
12085                case 0x03:
12086                case 0x04:
12087                case 0x05:
12088                case 0x06:
12089                case 0x07:
12090                case 0x08:
12091                case 0x09:
12092                case 0x0a:
12093                case 0x0b:
12094                case 0x0c:
12095                case 0x0d:
12096                case 0x0e:
12097                  goto op_semantics_88;
12098                  break;
12099                case 0x0f:
12100                  goto op_semantics_89;
12101                  break;
12102              }
12103            break;
12104          default: UNSUPPORTED(); break;
12105        }
12106      break;
12107    case 0xfd:
12108        GETBYTE ();
12109        switch (op[1] & 0xff)
12110        {
12111          case 0x00:
12112              GETBYTE ();
12113              switch (op[2] & 0x00)
12114              {
12115                case 0x00:
12116                  op_semantics_90:
12117                    {
12118                      /** 1111 1101 0000 a000 srca srcb	mulhi	%1, %2, %0 */
12119#line 873 "rx-decode.opc"
12120                      int a AU = (op[1] >> 3) & 0x01;
12121#line 873 "rx-decode.opc"
12122                      int srca AU = (op[2] >> 4) & 0x0f;
12123#line 873 "rx-decode.opc"
12124                      int srcb AU = op[2] & 0x0f;
12125                      if (trace)
12126                        {
12127                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12128                                 "/** 1111 1101 0000 a000 srca srcb	mulhi	%1, %2, %0 */",
12129                                 op[0], op[1], op[2]);
12130                          printf ("  a = 0x%x,", a);
12131                          printf ("  srca = 0x%x,", srca);
12132                          printf ("  srcb = 0x%x\n", srcb);
12133                        }
12134                      SYNTAX("mulhi	%1, %2, %0");
12135#line 873 "rx-decode.opc"
12136                      ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137
12138                    }
12139                  break;
12140              }
12141            break;
12142          case 0x01:
12143              GETBYTE ();
12144              switch (op[2] & 0x00)
12145              {
12146                case 0x00:
12147                  op_semantics_91:
12148                    {
12149                      /** 1111 1101 0000 a001 srca srcb	mullo	%1, %2, %0 */
12150#line 876 "rx-decode.opc"
12151                      int a AU = (op[1] >> 3) & 0x01;
12152#line 876 "rx-decode.opc"
12153                      int srca AU = (op[2] >> 4) & 0x0f;
12154#line 876 "rx-decode.opc"
12155                      int srcb AU = op[2] & 0x0f;
12156                      if (trace)
12157                        {
12158                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12159                                 "/** 1111 1101 0000 a001 srca srcb	mullo	%1, %2, %0 */",
12160                                 op[0], op[1], op[2]);
12161                          printf ("  a = 0x%x,", a);
12162                          printf ("  srca = 0x%x,", srca);
12163                          printf ("  srcb = 0x%x\n", srcb);
12164                        }
12165                      SYNTAX("mullo	%1, %2, %0");
12166#line 876 "rx-decode.opc"
12167                      ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168
12169                    }
12170                  break;
12171              }
12172            break;
12173          case 0x02:
12174              GETBYTE ();
12175              switch (op[2] & 0x00)
12176              {
12177                case 0x00:
12178                  op_semantics_92:
12179                    {
12180                      /** 1111 1101 0000 a010 srca srcb	mullh	%1, %2, %0 */
12181#line 1104 "rx-decode.opc"
12182                      int a AU = (op[1] >> 3) & 0x01;
12183#line 1104 "rx-decode.opc"
12184                      int srca AU = (op[2] >> 4) & 0x0f;
12185#line 1104 "rx-decode.opc"
12186                      int srcb AU = op[2] & 0x0f;
12187                      if (trace)
12188                        {
12189                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12190                                 "/** 1111 1101 0000 a010 srca srcb	mullh	%1, %2, %0 */",
12191                                 op[0], op[1], op[2]);
12192                          printf ("  a = 0x%x,", a);
12193                          printf ("  srca = 0x%x,", srca);
12194                          printf ("  srcb = 0x%x\n", srcb);
12195                        }
12196                      SYNTAX("mullh	%1, %2, %0");
12197#line 1104 "rx-decode.opc"
12198                      ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199
12200                    }
12201                  break;
12202              }
12203            break;
12204          case 0x03:
12205              GETBYTE ();
12206              switch (op[2] & 0x00)
12207              {
12208                case 0x00:
12209                  op_semantics_93:
12210                    {
12211                      /** 1111 1101 0000 a011 srca srcb 	emula	%1, %2, %0 */
12212#line 1089 "rx-decode.opc"
12213                      int a AU = (op[1] >> 3) & 0x01;
12214#line 1089 "rx-decode.opc"
12215                      int srca AU = (op[2] >> 4) & 0x0f;
12216#line 1089 "rx-decode.opc"
12217                      int srcb AU = op[2] & 0x0f;
12218                      if (trace)
12219                        {
12220                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12221                                 "/** 1111 1101 0000 a011 srca srcb 	emula	%1, %2, %0 */",
12222                                 op[0], op[1], op[2]);
12223                          printf ("  a = 0x%x,", a);
12224                          printf ("  srca = 0x%x,", srca);
12225                          printf ("  srcb = 0x%x\n", srcb);
12226                        }
12227                      SYNTAX("emula	%1, %2, %0");
12228#line 1089 "rx-decode.opc"
12229                      ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230
12231                    }
12232                  break;
12233              }
12234            break;
12235          case 0x04:
12236              GETBYTE ();
12237              switch (op[2] & 0x00)
12238              {
12239                case 0x00:
12240                  op_semantics_94:
12241                    {
12242                      /** 1111 1101 0000 a100 srca srcb	machi	%1, %2, %0 */
12243#line 879 "rx-decode.opc"
12244                      int a AU = (op[1] >> 3) & 0x01;
12245#line 879 "rx-decode.opc"
12246                      int srca AU = (op[2] >> 4) & 0x0f;
12247#line 879 "rx-decode.opc"
12248                      int srcb AU = op[2] & 0x0f;
12249                      if (trace)
12250                        {
12251                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12252                                 "/** 1111 1101 0000 a100 srca srcb	machi	%1, %2, %0 */",
12253                                 op[0], op[1], op[2]);
12254                          printf ("  a = 0x%x,", a);
12255                          printf ("  srca = 0x%x,", srca);
12256                          printf ("  srcb = 0x%x\n", srcb);
12257                        }
12258                      SYNTAX("machi	%1, %2, %0");
12259#line 879 "rx-decode.opc"
12260                      ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261
12262                    }
12263                  break;
12264              }
12265            break;
12266          case 0x05:
12267              GETBYTE ();
12268              switch (op[2] & 0x00)
12269              {
12270                case 0x00:
12271                  op_semantics_95:
12272                    {
12273                      /** 1111 1101 0000 a101 srca srcb	maclo	%1, %2, %0 */
12274#line 882 "rx-decode.opc"
12275                      int a AU = (op[1] >> 3) & 0x01;
12276#line 882 "rx-decode.opc"
12277                      int srca AU = (op[2] >> 4) & 0x0f;
12278#line 882 "rx-decode.opc"
12279                      int srcb AU = op[2] & 0x0f;
12280                      if (trace)
12281                        {
12282                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12283                                 "/** 1111 1101 0000 a101 srca srcb	maclo	%1, %2, %0 */",
12284                                 op[0], op[1], op[2]);
12285                          printf ("  a = 0x%x,", a);
12286                          printf ("  srca = 0x%x,", srca);
12287                          printf ("  srcb = 0x%x\n", srcb);
12288                        }
12289                      SYNTAX("maclo	%1, %2, %0");
12290#line 882 "rx-decode.opc"
12291                      ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292
12293                    }
12294                  break;
12295              }
12296            break;
12297          case 0x06:
12298              GETBYTE ();
12299              switch (op[2] & 0x00)
12300              {
12301                case 0x00:
12302                  op_semantics_96:
12303                    {
12304                      /** 1111 1101 0000 a110 srca srcb	maclh	%1, %2, %0 */
12305#line 1092 "rx-decode.opc"
12306                      int a AU = (op[1] >> 3) & 0x01;
12307#line 1092 "rx-decode.opc"
12308                      int srca AU = (op[2] >> 4) & 0x0f;
12309#line 1092 "rx-decode.opc"
12310                      int srcb AU = op[2] & 0x0f;
12311                      if (trace)
12312                        {
12313                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12314                                 "/** 1111 1101 0000 a110 srca srcb	maclh	%1, %2, %0 */",
12315                                 op[0], op[1], op[2]);
12316                          printf ("  a = 0x%x,", a);
12317                          printf ("  srca = 0x%x,", srca);
12318                          printf ("  srcb = 0x%x\n", srcb);
12319                        }
12320                      SYNTAX("maclh	%1, %2, %0");
12321#line 1092 "rx-decode.opc"
12322                      ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
12323
12324                    }
12325                  break;
12326              }
12327            break;
12328          case 0x07:
12329              GETBYTE ();
12330              switch (op[2] & 0x00)
12331              {
12332                case 0x00:
12333                  op_semantics_97:
12334                    {
12335                      /** 1111 1101 0000 a111 srca srcb 	emaca	%1, %2, %0 */
12336#line 1083 "rx-decode.opc"
12337                      int a AU = (op[1] >> 3) & 0x01;
12338#line 1083 "rx-decode.opc"
12339                      int srca AU = (op[2] >> 4) & 0x0f;
12340#line 1083 "rx-decode.opc"
12341                      int srcb AU = op[2] & 0x0f;
12342                      if (trace)
12343                        {
12344                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12345                                 "/** 1111 1101 0000 a111 srca srcb 	emaca	%1, %2, %0 */",
12346                                 op[0], op[1], op[2]);
12347                          printf ("  a = 0x%x,", a);
12348                          printf ("  srca = 0x%x,", srca);
12349                          printf ("  srcb = 0x%x\n", srcb);
12350                        }
12351                      SYNTAX("emaca	%1, %2, %0");
12352#line 1083 "rx-decode.opc"
12353                      ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
12354
12355                    }
12356                  break;
12357              }
12358            break;
12359          case 0x08:
12360              GETBYTE ();
12361              switch (op[2] & 0x00)
12362              {
12363                case 0x00:
12364                  goto op_semantics_90;
12365                  break;
12366              }
12367            break;
12368          case 0x09:
12369              GETBYTE ();
12370              switch (op[2] & 0x00)
12371              {
12372                case 0x00:
12373                  goto op_semantics_91;
12374                  break;
12375              }
12376            break;
12377          case 0x0a:
12378              GETBYTE ();
12379              switch (op[2] & 0x00)
12380              {
12381                case 0x00:
12382                  goto op_semantics_92;
12383                  break;
12384              }
12385            break;
12386          case 0x0b:
12387              GETBYTE ();
12388              switch (op[2] & 0x00)
12389              {
12390                case 0x00:
12391                  goto op_semantics_93;
12392                  break;
12393              }
12394            break;
12395          case 0x0c:
12396              GETBYTE ();
12397              switch (op[2] & 0x00)
12398              {
12399                case 0x00:
12400                  goto op_semantics_94;
12401                  break;
12402              }
12403            break;
12404          case 0x0d:
12405              GETBYTE ();
12406              switch (op[2] & 0x00)
12407              {
12408                case 0x00:
12409                  goto op_semantics_95;
12410                  break;
12411              }
12412            break;
12413          case 0x0e:
12414              GETBYTE ();
12415              switch (op[2] & 0x00)
12416              {
12417                case 0x00:
12418                  goto op_semantics_96;
12419                  break;
12420              }
12421            break;
12422          case 0x0f:
12423              GETBYTE ();
12424              switch (op[2] & 0x00)
12425              {
12426                case 0x00:
12427                  goto op_semantics_97;
12428                  break;
12429              }
12430            break;
12431          case 0x17:
12432              GETBYTE ();
12433              switch (op[2] & 0x70)
12434              {
12435                case 0x00:
12436                    {
12437                      /** 1111 1101 0001 0111 a000 rsrc	mvtachi	%1, %0 */
12438#line 885 "rx-decode.opc"
12439                      int a AU = (op[2] >> 7) & 0x01;
12440#line 885 "rx-decode.opc"
12441                      int rsrc AU = op[2] & 0x0f;
12442                      if (trace)
12443                        {
12444                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12445                                 "/** 1111 1101 0001 0111 a000 rsrc	mvtachi	%1, %0 */",
12446                                 op[0], op[1], op[2]);
12447                          printf ("  a = 0x%x,", a);
12448                          printf ("  rsrc = 0x%x\n", rsrc);
12449                        }
12450                      SYNTAX("mvtachi	%1, %0");
12451#line 885 "rx-decode.opc"
12452                      ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453
12454                    }
12455                  break;
12456                case 0x10:
12457                    {
12458                      /** 1111 1101 0001 0111 a001 rsrc	mvtaclo	%1, %0 */
12459#line 888 "rx-decode.opc"
12460                      int a AU = (op[2] >> 7) & 0x01;
12461#line 888 "rx-decode.opc"
12462                      int rsrc AU = op[2] & 0x0f;
12463                      if (trace)
12464                        {
12465                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12466                                 "/** 1111 1101 0001 0111 a001 rsrc	mvtaclo	%1, %0 */",
12467                                 op[0], op[1], op[2]);
12468                          printf ("  a = 0x%x,", a);
12469                          printf ("  rsrc = 0x%x\n", rsrc);
12470                        }
12471                      SYNTAX("mvtaclo	%1, %0");
12472#line 888 "rx-decode.opc"
12473                      ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474
12475                    }
12476                  break;
12477                case 0x30:
12478                    {
12479                      /** 1111 1101 0001 0111 a011 rsrc	mvtacgu	%1, %0 */
12480#line 1110 "rx-decode.opc"
12481                      int a AU = (op[2] >> 7) & 0x01;
12482#line 1110 "rx-decode.opc"
12483                      int rsrc AU = op[2] & 0x0f;
12484                      if (trace)
12485                        {
12486                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12487                                 "/** 1111 1101 0001 0111 a011 rsrc	mvtacgu	%1, %0 */",
12488                                 op[0], op[1], op[2]);
12489                          printf ("  a = 0x%x,", a);
12490                          printf ("  rsrc = 0x%x\n", rsrc);
12491                        }
12492                      SYNTAX("mvtacgu	%1, %0");
12493#line 1110 "rx-decode.opc"
12494                      ID(mvtacgu); SR(rsrc); DR(a+32); F_____;
12495
12496                    }
12497                  break;
12498                default: UNSUPPORTED(); break;
12499              }
12500            break;
12501          case 0x18:
12502              GETBYTE ();
12503              switch (op[2] & 0x6f)
12504              {
12505                case 0x00:
12506                    {
12507                      /** 1111 1101 0001 1000 a00i 0000	racw	#%1, %0 */
12508#line 900 "rx-decode.opc"
12509                      int a AU = (op[2] >> 7) & 0x01;
12510#line 900 "rx-decode.opc"
12511                      int i AU = (op[2] >> 4) & 0x01;
12512                      if (trace)
12513                        {
12514                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12515                                 "/** 1111 1101 0001 1000 a00i 0000	racw	#%1, %0 */",
12516                                 op[0], op[1], op[2]);
12517                          printf ("  a = 0x%x,", a);
12518                          printf ("  i = 0x%x\n", i);
12519                        }
12520                      SYNTAX("racw	#%1, %0");
12521#line 900 "rx-decode.opc"
12522                      ID(racw); SC(i+1); DR(a+32); F_____;
12523
12524                    /*----------------------------------------------------------------------*/
12525                    /* SAT									*/
12526
12527                    }
12528                  break;
12529                case 0x40:
12530                    {
12531                      /** 1111 1101 0001 1000 a10i 0000	rdacw	#%1, %0 */
12532#line 1119 "rx-decode.opc"
12533                      int a AU = (op[2] >> 7) & 0x01;
12534#line 1119 "rx-decode.opc"
12535                      int i AU = (op[2] >> 4) & 0x01;
12536                      if (trace)
12537                        {
12538                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12539                                 "/** 1111 1101 0001 1000 a10i 0000	rdacw	#%1, %0 */",
12540                                 op[0], op[1], op[2]);
12541                          printf ("  a = 0x%x,", a);
12542                          printf ("  i = 0x%x\n", i);
12543                        }
12544                      SYNTAX("rdacw	#%1, %0");
12545#line 1119 "rx-decode.opc"
12546                      ID(rdacw); SC(i+1); DR(a+32); F_____;
12547
12548                    }
12549                  break;
12550                default: UNSUPPORTED(); break;
12551              }
12552            break;
12553          case 0x19:
12554              GETBYTE ();
12555              switch (op[2] & 0x6f)
12556              {
12557                case 0x00:
12558                    {
12559                      /** 1111 1101 0001 1001 a00i 0000	racl	#%1, %0 */
12560#line 1113 "rx-decode.opc"
12561                      int a AU = (op[2] >> 7) & 0x01;
12562#line 1113 "rx-decode.opc"
12563                      int i AU = (op[2] >> 4) & 0x01;
12564                      if (trace)
12565                        {
12566                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12567                                 "/** 1111 1101 0001 1001 a00i 0000	racl	#%1, %0 */",
12568                                 op[0], op[1], op[2]);
12569                          printf ("  a = 0x%x,", a);
12570                          printf ("  i = 0x%x\n", i);
12571                        }
12572                      SYNTAX("racl	#%1, %0");
12573#line 1113 "rx-decode.opc"
12574                      ID(racl); SC(i+1); DR(a+32); F_____;
12575
12576                    }
12577                  break;
12578                case 0x40:
12579                    {
12580                      /** 1111 1101 0001 1001 a10i 0000	rdacl	#%1, %0 */
12581#line 1116 "rx-decode.opc"
12582                      int a AU = (op[2] >> 7) & 0x01;
12583#line 1116 "rx-decode.opc"
12584                      int i AU = (op[2] >> 4) & 0x01;
12585                      if (trace)
12586                        {
12587                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12588                                 "/** 1111 1101 0001 1001 a10i 0000	rdacl	#%1, %0 */",
12589                                 op[0], op[1], op[2]);
12590                          printf ("  a = 0x%x,", a);
12591                          printf ("  i = 0x%x\n", i);
12592                        }
12593                      SYNTAX("rdacl	#%1, %0");
12594#line 1116 "rx-decode.opc"
12595                      ID(rdacl); SC(i+1); DR(a+32); F_____;
12596
12597                    }
12598                  break;
12599                default: UNSUPPORTED(); break;
12600              }
12601            break;
12602          case 0x1e:
12603              GETBYTE ();
12604              switch (op[2] & 0x30)
12605              {
12606                case 0x00:
12607                  op_semantics_98:
12608                    {
12609                      /** 1111 1101 0001 111i a m00 rdst	mvfachi	#%2, %1, %0 */
12610#line 891 "rx-decode.opc"
12611                      int i AU = op[1] & 0x01;
12612#line 891 "rx-decode.opc"
12613                      int a AU = (op[2] >> 7) & 0x01;
12614#line 891 "rx-decode.opc"
12615                      int m AU = (op[2] >> 6) & 0x01;
12616#line 891 "rx-decode.opc"
12617                      int rdst AU = op[2] & 0x0f;
12618                      if (trace)
12619                        {
12620                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12621                                 "/** 1111 1101 0001 111i a m00 rdst	mvfachi	#%2, %1, %0 */",
12622                                 op[0], op[1], op[2]);
12623                          printf ("  i = 0x%x,", i);
12624                          printf ("  a = 0x%x,", a);
12625                          printf ("  m = 0x%x,", m);
12626                          printf ("  rdst = 0x%x\n", rdst);
12627                        }
12628                      SYNTAX("mvfachi	#%2, %1, %0");
12629#line 891 "rx-decode.opc"
12630                      ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631
12632                    }
12633                  break;
12634                case 0x10:
12635                  op_semantics_99:
12636                    {
12637                      /** 1111 1101 0001 111i a m01 rdst	mvfaclo	#%2, %1, %0 */
12638#line 897 "rx-decode.opc"
12639                      int i AU = op[1] & 0x01;
12640#line 897 "rx-decode.opc"
12641                      int a AU = (op[2] >> 7) & 0x01;
12642#line 897 "rx-decode.opc"
12643                      int m AU = (op[2] >> 6) & 0x01;
12644#line 897 "rx-decode.opc"
12645                      int rdst AU = op[2] & 0x0f;
12646                      if (trace)
12647                        {
12648                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12649                                 "/** 1111 1101 0001 111i a m01 rdst	mvfaclo	#%2, %1, %0 */",
12650                                 op[0], op[1], op[2]);
12651                          printf ("  i = 0x%x,", i);
12652                          printf ("  a = 0x%x,", a);
12653                          printf ("  m = 0x%x,", m);
12654                          printf ("  rdst = 0x%x\n", rdst);
12655                        }
12656                      SYNTAX("mvfaclo	#%2, %1, %0");
12657#line 897 "rx-decode.opc"
12658                      ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659
12660                    }
12661                  break;
12662                case 0x20:
12663                  op_semantics_100:
12664                    {
12665                      /** 1111 1101 0001 111i a m10 rdst	mvfacmi	#%2, %1, %0 */
12666#line 894 "rx-decode.opc"
12667                      int i AU = op[1] & 0x01;
12668#line 894 "rx-decode.opc"
12669                      int a AU = (op[2] >> 7) & 0x01;
12670#line 894 "rx-decode.opc"
12671                      int m AU = (op[2] >> 6) & 0x01;
12672#line 894 "rx-decode.opc"
12673                      int rdst AU = op[2] & 0x0f;
12674                      if (trace)
12675                        {
12676                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12677                                 "/** 1111 1101 0001 111i a m10 rdst	mvfacmi	#%2, %1, %0 */",
12678                                 op[0], op[1], op[2]);
12679                          printf ("  i = 0x%x,", i);
12680                          printf ("  a = 0x%x,", a);
12681                          printf ("  m = 0x%x,", m);
12682                          printf ("  rdst = 0x%x\n", rdst);
12683                        }
12684                      SYNTAX("mvfacmi	#%2, %1, %0");
12685#line 894 "rx-decode.opc"
12686                      ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687
12688                    }
12689                  break;
12690                case 0x30:
12691                  op_semantics_101:
12692                    {
12693                      /** 1111 1101 0001 111i a m11 rdst	mvfacgu	#%2, %1, %0 */
12694#line 1107 "rx-decode.opc"
12695                      int i AU = op[1] & 0x01;
12696#line 1107 "rx-decode.opc"
12697                      int a AU = (op[2] >> 7) & 0x01;
12698#line 1107 "rx-decode.opc"
12699                      int m AU = (op[2] >> 6) & 0x01;
12700#line 1107 "rx-decode.opc"
12701                      int rdst AU = op[2] & 0x0f;
12702                      if (trace)
12703                        {
12704                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12705                                 "/** 1111 1101 0001 111i a m11 rdst	mvfacgu	#%2, %1, %0 */",
12706                                 op[0], op[1], op[2]);
12707                          printf ("  i = 0x%x,", i);
12708                          printf ("  a = 0x%x,", a);
12709                          printf ("  m = 0x%x,", m);
12710                          printf ("  rdst = 0x%x\n", rdst);
12711                        }
12712                      SYNTAX("mvfacgu	#%2, %1, %0");
12713#line 1107 "rx-decode.opc"
12714                      ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715
12716                    }
12717                  break;
12718              }
12719            break;
12720          case 0x1f:
12721              GETBYTE ();
12722              switch (op[2] & 0x30)
12723              {
12724                case 0x00:
12725                  goto op_semantics_98;
12726                  break;
12727                case 0x10:
12728                  goto op_semantics_99;
12729                  break;
12730                case 0x20:
12731                  goto op_semantics_100;
12732                  break;
12733                case 0x30:
12734                  goto op_semantics_101;
12735                  break;
12736              }
12737            break;
12738          case 0x20:
12739              GETBYTE ();
12740              switch (op[2] & 0x00)
12741              {
12742                case 0x00:
12743                  op_semantics_102:
12744                    {
12745                      /** 1111 1101 0010 0p sz rdst rsrc	mov%s	%1, %0 */
12746#line 369 "rx-decode.opc"
12747                      int p AU = (op[1] >> 2) & 0x01;
12748#line 369 "rx-decode.opc"
12749                      int sz AU = op[1] & 0x03;
12750#line 369 "rx-decode.opc"
12751                      int rdst AU = (op[2] >> 4) & 0x0f;
12752#line 369 "rx-decode.opc"
12753                      int rsrc AU = op[2] & 0x0f;
12754                      if (trace)
12755                        {
12756                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12757                                 "/** 1111 1101 0010 0p sz rdst rsrc	mov%s	%1, %0 */",
12758                                 op[0], op[1], op[2]);
12759                          printf ("  p = 0x%x,", p);
12760                          printf ("  sz = 0x%x,", sz);
12761                          printf ("  rdst = 0x%x,", rdst);
12762                          printf ("  rsrc = 0x%x\n", rsrc);
12763                        }
12764                      SYNTAX("mov%s	%1, %0");
12765#line 369 "rx-decode.opc"
12766                      ID(mov); sBWL (sz); SR(rsrc); F_____;
12767                      OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768
12769                    }
12770                  break;
12771              }
12772            break;
12773          case 0x21:
12774              GETBYTE ();
12775              switch (op[2] & 0x00)
12776              {
12777                case 0x00:
12778                  goto op_semantics_102;
12779                  break;
12780              }
12781            break;
12782          case 0x22:
12783              GETBYTE ();
12784              switch (op[2] & 0x00)
12785              {
12786                case 0x00:
12787                  goto op_semantics_102;
12788                  break;
12789              }
12790            break;
12791          case 0x24:
12792              GETBYTE ();
12793              switch (op[2] & 0x00)
12794              {
12795                case 0x00:
12796                  goto op_semantics_102;
12797                  break;
12798              }
12799            break;
12800          case 0x25:
12801              GETBYTE ();
12802              switch (op[2] & 0x00)
12803              {
12804                case 0x00:
12805                  goto op_semantics_102;
12806                  break;
12807              }
12808            break;
12809          case 0x26:
12810              GETBYTE ();
12811              switch (op[2] & 0x00)
12812              {
12813                case 0x00:
12814                  goto op_semantics_102;
12815                  break;
12816              }
12817            break;
12818          case 0x27:
12819              GETBYTE ();
12820              switch (op[2] & 0x00)
12821              {
12822                case 0x00:
12823                    {
12824                      /** 1111 1101 0010 0111 rdst rsrc	movco	%1, [%0] */
12825#line 1071 "rx-decode.opc"
12826                      int rdst AU = (op[2] >> 4) & 0x0f;
12827#line 1071 "rx-decode.opc"
12828                      int rsrc AU = op[2] & 0x0f;
12829                      if (trace)
12830                        {
12831                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12832                                 "/** 1111 1101 0010 0111 rdst rsrc	movco	%1, [%0] */",
12833                                 op[0], op[1], op[2]);
12834                          printf ("  rdst = 0x%x,", rdst);
12835                          printf ("  rsrc = 0x%x\n", rsrc);
12836                        }
12837                      SYNTAX("movco	%1, [%0]");
12838#line 1071 "rx-decode.opc"
12839                       ID(movco); SR(rsrc); DR(rdst); F_____;
12840
12841                    }
12842                  break;
12843              }
12844            break;
12845          case 0x28:
12846              GETBYTE ();
12847              switch (op[2] & 0x00)
12848              {
12849                case 0x00:
12850                  op_semantics_103:
12851                    {
12852                      /** 1111 1101 0010 1p sz rsrc rdst	mov%s	%1, %0 */
12853#line 373 "rx-decode.opc"
12854                      int p AU = (op[1] >> 2) & 0x01;
12855#line 373 "rx-decode.opc"
12856                      int sz AU = op[1] & 0x03;
12857#line 373 "rx-decode.opc"
12858                      int rsrc AU = (op[2] >> 4) & 0x0f;
12859#line 373 "rx-decode.opc"
12860                      int rdst AU = op[2] & 0x0f;
12861                      if (trace)
12862                        {
12863                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12864                                 "/** 1111 1101 0010 1p sz rsrc rdst	mov%s	%1, %0 */",
12865                                 op[0], op[1], op[2]);
12866                          printf ("  p = 0x%x,", p);
12867                          printf ("  sz = 0x%x,", sz);
12868                          printf ("  rsrc = 0x%x,", rsrc);
12869                          printf ("  rdst = 0x%x\n", rdst);
12870                        }
12871                      SYNTAX("mov%s	%1, %0");
12872#line 373 "rx-decode.opc"
12873                      ID(mov); sBWL (sz); DR(rdst); F_____;
12874                      OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875
12876                    }
12877                  break;
12878              }
12879            break;
12880          case 0x29:
12881              GETBYTE ();
12882              switch (op[2] & 0x00)
12883              {
12884                case 0x00:
12885                  goto op_semantics_103;
12886                  break;
12887              }
12888            break;
12889          case 0x2a:
12890              GETBYTE ();
12891              switch (op[2] & 0x00)
12892              {
12893                case 0x00:
12894                  goto op_semantics_103;
12895                  break;
12896              }
12897            break;
12898          case 0x2c:
12899              GETBYTE ();
12900              switch (op[2] & 0x00)
12901              {
12902                case 0x00:
12903                  goto op_semantics_103;
12904                  break;
12905              }
12906            break;
12907          case 0x2d:
12908              GETBYTE ();
12909              switch (op[2] & 0x00)
12910              {
12911                case 0x00:
12912                  goto op_semantics_103;
12913                  break;
12914              }
12915            break;
12916          case 0x2e:
12917              GETBYTE ();
12918              switch (op[2] & 0x00)
12919              {
12920                case 0x00:
12921                  goto op_semantics_103;
12922                  break;
12923              }
12924            break;
12925          case 0x2f:
12926              GETBYTE ();
12927              switch (op[2] & 0x00)
12928              {
12929                case 0x00:
12930                    {
12931                      /** 1111 1101 0010 1111 rsrc rdst	movli	[%1], %0 */
12932#line 1074 "rx-decode.opc"
12933                      int rsrc AU = (op[2] >> 4) & 0x0f;
12934#line 1074 "rx-decode.opc"
12935                      int rdst AU = op[2] & 0x0f;
12936                      if (trace)
12937                        {
12938                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12939                                 "/** 1111 1101 0010 1111 rsrc rdst	movli	[%1], %0 */",
12940                                 op[0], op[1], op[2]);
12941                          printf ("  rsrc = 0x%x,", rsrc);
12942                          printf ("  rdst = 0x%x\n", rdst);
12943                        }
12944                      SYNTAX("movli	[%1], %0");
12945#line 1074 "rx-decode.opc"
12946                       ID(movli); SR(rsrc); DR(rdst); F_____;
12947
12948                    }
12949                  break;
12950              }
12951            break;
12952          case 0x38:
12953              GETBYTE ();
12954              switch (op[2] & 0x00)
12955              {
12956                case 0x00:
12957                  op_semantics_104:
12958                    {
12959                      /** 1111 1101 0011 1p sz rsrc rdst	movu%s	%1, %0 */
12960#line 383 "rx-decode.opc"
12961                      int p AU = (op[1] >> 2) & 0x01;
12962#line 383 "rx-decode.opc"
12963                      int sz AU = op[1] & 0x03;
12964#line 383 "rx-decode.opc"
12965                      int rsrc AU = (op[2] >> 4) & 0x0f;
12966#line 383 "rx-decode.opc"
12967                      int rdst AU = op[2] & 0x0f;
12968                      if (trace)
12969                        {
12970                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12971                                 "/** 1111 1101 0011 1p sz rsrc rdst	movu%s	%1, %0 */",
12972                                 op[0], op[1], op[2]);
12973                          printf ("  p = 0x%x,", p);
12974                          printf ("  sz = 0x%x,", sz);
12975                          printf ("  rsrc = 0x%x,", rsrc);
12976                          printf ("  rdst = 0x%x\n", rdst);
12977                        }
12978                      SYNTAX("movu%s	%1, %0");
12979#line 383 "rx-decode.opc"
12980                      ID(mov); uBW (sz); DR(rdst); F_____;
12981                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982
12983                    /*----------------------------------------------------------------------*/
12984                    /* PUSH/POP								*/
12985
12986                    }
12987                  break;
12988              }
12989            break;
12990          case 0x39:
12991              GETBYTE ();
12992              switch (op[2] & 0x00)
12993              {
12994                case 0x00:
12995                  goto op_semantics_104;
12996                  break;
12997              }
12998            break;
12999          case 0x3a:
13000              GETBYTE ();
13001              switch (op[2] & 0x00)
13002              {
13003                case 0x00:
13004                  goto op_semantics_104;
13005                  break;
13006              }
13007            break;
13008          case 0x3c:
13009              GETBYTE ();
13010              switch (op[2] & 0x00)
13011              {
13012                case 0x00:
13013                  goto op_semantics_104;
13014                  break;
13015              }
13016            break;
13017          case 0x3d:
13018              GETBYTE ();
13019              switch (op[2] & 0x00)
13020              {
13021                case 0x00:
13022                  goto op_semantics_104;
13023                  break;
13024              }
13025            break;
13026          case 0x3e:
13027              GETBYTE ();
13028              switch (op[2] & 0x00)
13029              {
13030                case 0x00:
13031                  goto op_semantics_104;
13032                  break;
13033              }
13034            break;
13035          case 0x44:
13036              GETBYTE ();
13037              switch (op[2] & 0x00)
13038              {
13039                case 0x00:
13040                  op_semantics_105:
13041                    {
13042                      /** 1111 1101 0100 a100 srca srcb	msbhi	%1, %2, %0 */
13043#line 1095 "rx-decode.opc"
13044                      int a AU = (op[1] >> 3) & 0x01;
13045#line 1095 "rx-decode.opc"
13046                      int srca AU = (op[2] >> 4) & 0x0f;
13047#line 1095 "rx-decode.opc"
13048                      int srcb AU = op[2] & 0x0f;
13049                      if (trace)
13050                        {
13051                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13052                                 "/** 1111 1101 0100 a100 srca srcb	msbhi	%1, %2, %0 */",
13053                                 op[0], op[1], op[2]);
13054                          printf ("  a = 0x%x,", a);
13055                          printf ("  srca = 0x%x,", srca);
13056                          printf ("  srcb = 0x%x\n", srcb);
13057                        }
13058                      SYNTAX("msbhi	%1, %2, %0");
13059#line 1095 "rx-decode.opc"
13060                      ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061
13062                    }
13063                  break;
13064              }
13065            break;
13066          case 0x45:
13067              GETBYTE ();
13068              switch (op[2] & 0x00)
13069              {
13070                case 0x00:
13071                  op_semantics_106:
13072                    {
13073                      /** 1111 1101 0100 a101 srca srcb	msblo	%1, %2, %0 */
13074#line 1101 "rx-decode.opc"
13075                      int a AU = (op[1] >> 3) & 0x01;
13076#line 1101 "rx-decode.opc"
13077                      int srca AU = (op[2] >> 4) & 0x0f;
13078#line 1101 "rx-decode.opc"
13079                      int srcb AU = op[2] & 0x0f;
13080                      if (trace)
13081                        {
13082                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13083                                 "/** 1111 1101 0100 a101 srca srcb	msblo	%1, %2, %0 */",
13084                                 op[0], op[1], op[2]);
13085                          printf ("  a = 0x%x,", a);
13086                          printf ("  srca = 0x%x,", srca);
13087                          printf ("  srcb = 0x%x\n", srcb);
13088                        }
13089                      SYNTAX("msblo	%1, %2, %0");
13090#line 1101 "rx-decode.opc"
13091                      ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
13092
13093                    }
13094                  break;
13095              }
13096            break;
13097          case 0x46:
13098              GETBYTE ();
13099              switch (op[2] & 0x00)
13100              {
13101                case 0x00:
13102                  op_semantics_107:
13103                    {
13104                      /** 1111 1101 0100 a110 srca srcb	msblh	%1, %2, %0 */
13105#line 1098 "rx-decode.opc"
13106                      int a AU = (op[1] >> 3) & 0x01;
13107#line 1098 "rx-decode.opc"
13108                      int srca AU = (op[2] >> 4) & 0x0f;
13109#line 1098 "rx-decode.opc"
13110                      int srcb AU = op[2] & 0x0f;
13111                      if (trace)
13112                        {
13113                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13114                                 "/** 1111 1101 0100 a110 srca srcb	msblh	%1, %2, %0 */",
13115                                 op[0], op[1], op[2]);
13116                          printf ("  a = 0x%x,", a);
13117                          printf ("  srca = 0x%x,", srca);
13118                          printf ("  srcb = 0x%x\n", srcb);
13119                        }
13120                      SYNTAX("msblh	%1, %2, %0");
13121#line 1098 "rx-decode.opc"
13122                      ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
13123
13124                    }
13125                  break;
13126              }
13127            break;
13128          case 0x47:
13129              GETBYTE ();
13130              switch (op[2] & 0x00)
13131              {
13132                case 0x00:
13133                  op_semantics_108:
13134                    {
13135                      /** 1111 1101 0100 a111 srca srcb 	emsba	%1, %2, %0 */
13136#line 1086 "rx-decode.opc"
13137                      int a AU = (op[1] >> 3) & 0x01;
13138#line 1086 "rx-decode.opc"
13139                      int srca AU = (op[2] >> 4) & 0x0f;
13140#line 1086 "rx-decode.opc"
13141                      int srcb AU = op[2] & 0x0f;
13142                      if (trace)
13143                        {
13144                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13145                                 "/** 1111 1101 0100 a111 srca srcb 	emsba	%1, %2, %0 */",
13146                                 op[0], op[1], op[2]);
13147                          printf ("  a = 0x%x,", a);
13148                          printf ("  srca = 0x%x,", srca);
13149                          printf ("  srcb = 0x%x\n", srcb);
13150                        }
13151                      SYNTAX("emsba	%1, %2, %0");
13152#line 1086 "rx-decode.opc"
13153                      ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
13154
13155                    }
13156                  break;
13157              }
13158            break;
13159          case 0x4c:
13160              GETBYTE ();
13161              switch (op[2] & 0x00)
13162              {
13163                case 0x00:
13164                  goto op_semantics_105;
13165                  break;
13166              }
13167            break;
13168          case 0x4d:
13169              GETBYTE ();
13170              switch (op[2] & 0x00)
13171              {
13172                case 0x00:
13173                  goto op_semantics_106;
13174                  break;
13175              }
13176            break;
13177          case 0x4e:
13178              GETBYTE ();
13179              switch (op[2] & 0x00)
13180              {
13181                case 0x00:
13182                  goto op_semantics_107;
13183                  break;
13184              }
13185            break;
13186          case 0x4f:
13187              GETBYTE ();
13188              switch (op[2] & 0x00)
13189              {
13190                case 0x00:
13191                  goto op_semantics_108;
13192                  break;
13193              }
13194            break;
13195          case 0x60:
13196              GETBYTE ();
13197              switch (op[2] & 0x00)
13198              {
13199                case 0x00:
13200                    {
13201                      /** 1111 1101 0110 0000 rsrc rdst	shlr	%2, %0 */
13202#line 754 "rx-decode.opc"
13203                      int rsrc AU = (op[2] >> 4) & 0x0f;
13204#line 754 "rx-decode.opc"
13205                      int rdst AU = op[2] & 0x0f;
13206                      if (trace)
13207                        {
13208                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13209                                 "/** 1111 1101 0110 0000 rsrc rdst	shlr	%2, %0 */",
13210                                 op[0], op[1], op[2]);
13211                          printf ("  rsrc = 0x%x,", rsrc);
13212                          printf ("  rdst = 0x%x\n", rdst);
13213                        }
13214                      SYNTAX("shlr	%2, %0");
13215#line 754 "rx-decode.opc"
13216                      ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217
13218                    }
13219                  break;
13220              }
13221            break;
13222          case 0x61:
13223              GETBYTE ();
13224              switch (op[2] & 0x00)
13225              {
13226                case 0x00:
13227                    {
13228                      /** 1111 1101 0110 0001 rsrc rdst	shar	%2, %0 */
13229#line 744 "rx-decode.opc"
13230                      int rsrc AU = (op[2] >> 4) & 0x0f;
13231#line 744 "rx-decode.opc"
13232                      int rdst AU = op[2] & 0x0f;
13233                      if (trace)
13234                        {
13235                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13236                                 "/** 1111 1101 0110 0001 rsrc rdst	shar	%2, %0 */",
13237                                 op[0], op[1], op[2]);
13238                          printf ("  rsrc = 0x%x,", rsrc);
13239                          printf ("  rdst = 0x%x\n", rdst);
13240                        }
13241                      SYNTAX("shar	%2, %0");
13242#line 744 "rx-decode.opc"
13243                      ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244
13245                    }
13246                  break;
13247              }
13248            break;
13249          case 0x62:
13250              GETBYTE ();
13251              switch (op[2] & 0x00)
13252              {
13253                case 0x00:
13254                    {
13255                      /** 1111 1101 0110 0010 rsrc rdst	shll	%2, %0 */
13256#line 734 "rx-decode.opc"
13257                      int rsrc AU = (op[2] >> 4) & 0x0f;
13258#line 734 "rx-decode.opc"
13259                      int rdst AU = op[2] & 0x0f;
13260                      if (trace)
13261                        {
13262                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13263                                 "/** 1111 1101 0110 0010 rsrc rdst	shll	%2, %0 */",
13264                                 op[0], op[1], op[2]);
13265                          printf ("  rsrc = 0x%x,", rsrc);
13266                          printf ("  rdst = 0x%x\n", rdst);
13267                        }
13268                      SYNTAX("shll	%2, %0");
13269#line 734 "rx-decode.opc"
13270                      ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
13271
13272                    }
13273                  break;
13274              }
13275            break;
13276          case 0x64:
13277              GETBYTE ();
13278              switch (op[2] & 0x00)
13279              {
13280                case 0x00:
13281                    {
13282                      /** 1111 1101 0110 0100 rsrc rdst	rotr	%1, %0 */
13283#line 778 "rx-decode.opc"
13284                      int rsrc AU = (op[2] >> 4) & 0x0f;
13285#line 778 "rx-decode.opc"
13286                      int rdst AU = op[2] & 0x0f;
13287                      if (trace)
13288                        {
13289                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13290                                 "/** 1111 1101 0110 0100 rsrc rdst	rotr	%1, %0 */",
13291                                 op[0], op[1], op[2]);
13292                          printf ("  rsrc = 0x%x,", rsrc);
13293                          printf ("  rdst = 0x%x\n", rdst);
13294                        }
13295                      SYNTAX("rotr	%1, %0");
13296#line 778 "rx-decode.opc"
13297                      ID(rotr); SR(rsrc); DR(rdst); F__SZC;
13298
13299                    }
13300                  break;
13301              }
13302            break;
13303          case 0x65:
13304              GETBYTE ();
13305              switch (op[2] & 0x00)
13306              {
13307                case 0x00:
13308                    {
13309                      /** 1111 1101 0110 0101 rsrc rdst	revw	%1, %0 */
13310#line 781 "rx-decode.opc"
13311                      int rsrc AU = (op[2] >> 4) & 0x0f;
13312#line 781 "rx-decode.opc"
13313                      int rdst AU = op[2] & 0x0f;
13314                      if (trace)
13315                        {
13316                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13317                                 "/** 1111 1101 0110 0101 rsrc rdst	revw	%1, %0 */",
13318                                 op[0], op[1], op[2]);
13319                          printf ("  rsrc = 0x%x,", rsrc);
13320                          printf ("  rdst = 0x%x\n", rdst);
13321                        }
13322                      SYNTAX("revw	%1, %0");
13323#line 781 "rx-decode.opc"
13324                      ID(revw); SR(rsrc); DR(rdst);
13325
13326                    }
13327                  break;
13328              }
13329            break;
13330          case 0x66:
13331              GETBYTE ();
13332              switch (op[2] & 0x00)
13333              {
13334                case 0x00:
13335                    {
13336                      /** 1111 1101 0110 0110 rsrc rdst	rotl	%1, %0 */
13337#line 772 "rx-decode.opc"
13338                      int rsrc AU = (op[2] >> 4) & 0x0f;
13339#line 772 "rx-decode.opc"
13340                      int rdst AU = op[2] & 0x0f;
13341                      if (trace)
13342                        {
13343                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13344                                 "/** 1111 1101 0110 0110 rsrc rdst	rotl	%1, %0 */",
13345                                 op[0], op[1], op[2]);
13346                          printf ("  rsrc = 0x%x,", rsrc);
13347                          printf ("  rdst = 0x%x\n", rdst);
13348                        }
13349                      SYNTAX("rotl	%1, %0");
13350#line 772 "rx-decode.opc"
13351                      ID(rotl); SR(rsrc); DR(rdst); F__SZC;
13352
13353                    }
13354                  break;
13355              }
13356            break;
13357          case 0x67:
13358              GETBYTE ();
13359              switch (op[2] & 0x00)
13360              {
13361                case 0x00:
13362                    {
13363                      /** 1111 1101 0110 0111 rsrc rdst	revl	%1, %0 */
13364#line 784 "rx-decode.opc"
13365                      int rsrc AU = (op[2] >> 4) & 0x0f;
13366#line 784 "rx-decode.opc"
13367                      int rdst AU = op[2] & 0x0f;
13368                      if (trace)
13369                        {
13370                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13371                                 "/** 1111 1101 0110 0111 rsrc rdst	revl	%1, %0 */",
13372                                 op[0], op[1], op[2]);
13373                          printf ("  rsrc = 0x%x,", rsrc);
13374                          printf ("  rdst = 0x%x\n", rdst);
13375                        }
13376                      SYNTAX("revl	%1, %0");
13377#line 784 "rx-decode.opc"
13378                      ID(revl); SR(rsrc); DR(rdst);
13379
13380                    /*----------------------------------------------------------------------*/
13381                    /* BRANCH								*/
13382
13383                    }
13384                  break;
13385              }
13386            break;
13387          case 0x68:
13388              GETBYTE ();
13389              switch (op[2] & 0x00)
13390              {
13391                case 0x00:
13392                  op_semantics_109:
13393                    {
13394                      /** 1111 1101 0110 100c rsrc rdst	mvtc	%1, %0 */
13395#line 1035 "rx-decode.opc"
13396                      int c AU = op[1] & 0x01;
13397#line 1035 "rx-decode.opc"
13398                      int rsrc AU = (op[2] >> 4) & 0x0f;
13399#line 1035 "rx-decode.opc"
13400                      int rdst AU = op[2] & 0x0f;
13401                      if (trace)
13402                        {
13403                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13404                                 "/** 1111 1101 0110 100c rsrc rdst	mvtc	%1, %0 */",
13405                                 op[0], op[1], op[2]);
13406                          printf ("  c = 0x%x,", c);
13407                          printf ("  rsrc = 0x%x,", rsrc);
13408                          printf ("  rdst = 0x%x\n", rdst);
13409                        }
13410                      SYNTAX("mvtc	%1, %0");
13411#line 1035 "rx-decode.opc"
13412                      ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413
13414                    }
13415                  break;
13416              }
13417            break;
13418          case 0x69:
13419              GETBYTE ();
13420              switch (op[2] & 0x00)
13421              {
13422                case 0x00:
13423                  goto op_semantics_109;
13424                  break;
13425              }
13426            break;
13427          case 0x6a:
13428              GETBYTE ();
13429              switch (op[2] & 0x00)
13430              {
13431                case 0x00:
13432                  op_semantics_110:
13433                    {
13434                      /** 1111 1101 0110 101s rsrc rdst	mvfc	%1, %0 */
13435#line 1038 "rx-decode.opc"
13436                      int s AU = op[1] & 0x01;
13437#line 1038 "rx-decode.opc"
13438                      int rsrc AU = (op[2] >> 4) & 0x0f;
13439#line 1038 "rx-decode.opc"
13440                      int rdst AU = op[2] & 0x0f;
13441                      if (trace)
13442                        {
13443                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13444                                 "/** 1111 1101 0110 101s rsrc rdst	mvfc	%1, %0 */",
13445                                 op[0], op[1], op[2]);
13446                          printf ("  s = 0x%x,", s);
13447                          printf ("  rsrc = 0x%x,", rsrc);
13448                          printf ("  rdst = 0x%x\n", rdst);
13449                        }
13450                      SYNTAX("mvfc	%1, %0");
13451#line 1038 "rx-decode.opc"
13452                      ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453
13454                    /*----------------------------------------------------------------------*/
13455                    /* INTERRUPTS								*/
13456
13457                    }
13458                  break;
13459              }
13460            break;
13461          case 0x6b:
13462              GETBYTE ();
13463              switch (op[2] & 0x00)
13464              {
13465                case 0x00:
13466                  goto op_semantics_110;
13467                  break;
13468              }
13469            break;
13470          case 0x6c:
13471              GETBYTE ();
13472              switch (op[2] & 0x00)
13473              {
13474                case 0x00:
13475                  op_semantics_111:
13476                    {
13477                      /** 1111 1101 0110 110i mmmm rdst	rotr	#%1, %0 */
13478#line 775 "rx-decode.opc"
13479                      int i AU = op[1] & 0x01;
13480#line 775 "rx-decode.opc"
13481                      int mmmm AU = (op[2] >> 4) & 0x0f;
13482#line 775 "rx-decode.opc"
13483                      int rdst AU = op[2] & 0x0f;
13484                      if (trace)
13485                        {
13486                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13487                                 "/** 1111 1101 0110 110i mmmm rdst	rotr	#%1, %0 */",
13488                                 op[0], op[1], op[2]);
13489                          printf ("  i = 0x%x,", i);
13490                          printf ("  mmmm = 0x%x,", mmmm);
13491                          printf ("  rdst = 0x%x\n", rdst);
13492                        }
13493                      SYNTAX("rotr	#%1, %0");
13494#line 775 "rx-decode.opc"
13495                      ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496
13497                    }
13498                  break;
13499              }
13500            break;
13501          case 0x6d:
13502              GETBYTE ();
13503              switch (op[2] & 0x00)
13504              {
13505                case 0x00:
13506                  goto op_semantics_111;
13507                  break;
13508              }
13509            break;
13510          case 0x6e:
13511              GETBYTE ();
13512              switch (op[2] & 0x00)
13513              {
13514                case 0x00:
13515                  op_semantics_112:
13516                    {
13517                      /** 1111 1101 0110 111i mmmm rdst	rotl	#%1, %0 */
13518#line 769 "rx-decode.opc"
13519                      int i AU = op[1] & 0x01;
13520#line 769 "rx-decode.opc"
13521                      int mmmm AU = (op[2] >> 4) & 0x0f;
13522#line 769 "rx-decode.opc"
13523                      int rdst AU = op[2] & 0x0f;
13524                      if (trace)
13525                        {
13526                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13527                                 "/** 1111 1101 0110 111i mmmm rdst	rotl	#%1, %0 */",
13528                                 op[0], op[1], op[2]);
13529                          printf ("  i = 0x%x,", i);
13530                          printf ("  mmmm = 0x%x,", mmmm);
13531                          printf ("  rdst = 0x%x\n", rdst);
13532                        }
13533                      SYNTAX("rotl	#%1, %0");
13534#line 769 "rx-decode.opc"
13535                      ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536
13537                    }
13538                  break;
13539              }
13540            break;
13541          case 0x6f:
13542              GETBYTE ();
13543              switch (op[2] & 0x00)
13544              {
13545                case 0x00:
13546                  goto op_semantics_112;
13547                  break;
13548              }
13549            break;
13550          case 0x70:
13551              GETBYTE ();
13552              switch (op[2] & 0xf0)
13553              {
13554                case 0x20:
13555                  op_semantics_113:
13556                    {
13557                      /** 1111 1101 0111 im00 0010rdst	adc	#%1, %0 */
13558#line 513 "rx-decode.opc"
13559                      int im AU = (op[1] >> 2) & 0x03;
13560#line 513 "rx-decode.opc"
13561                      int rdst AU = op[2] & 0x0f;
13562                      if (trace)
13563                        {
13564                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13565                                 "/** 1111 1101 0111 im00 0010rdst	adc	#%1, %0 */",
13566                                 op[0], op[1], op[2]);
13567                          printf ("  im = 0x%x,", im);
13568                          printf ("  rdst = 0x%x\n", rdst);
13569                        }
13570                      SYNTAX("adc	#%1, %0");
13571#line 513 "rx-decode.opc"
13572                      ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
13573
13574                    }
13575                  break;
13576                case 0x40:
13577                  op_semantics_114:
13578                    {
13579                      /** 1111 1101 0111 im00 0100rdst	max	#%1, %0 */
13580#line 595 "rx-decode.opc"
13581                      int im AU = (op[1] >> 2) & 0x03;
13582#line 595 "rx-decode.opc"
13583                      int rdst AU = op[2] & 0x0f;
13584                      if (trace)
13585                        {
13586                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13587                                 "/** 1111 1101 0111 im00 0100rdst	max	#%1, %0 */",
13588                                 op[0], op[1], op[2]);
13589                          printf ("  im = 0x%x,", im);
13590                          printf ("  rdst = 0x%x\n", rdst);
13591                        }
13592                      SYNTAX("max	#%1, %0");
13593#line 595 "rx-decode.opc"
13594                      int val = IMMex (im);
13595                      if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596                        {
13597                          ID (nop7);
13598                          SYNTAX("nop\t; max\t#0x80000000, r0");
13599                        }
13600                      else
13601                        {
13602                          ID(max);
13603                        }
13604                      DR(rdst); SC(val);
13605
13606                    }
13607                  break;
13608                case 0x50:
13609                  op_semantics_115:
13610                    {
13611                      /** 1111 1101 0111 im00 0101rdst	min	#%1, %0 */
13612#line 625 "rx-decode.opc"
13613                      int im AU = (op[1] >> 2) & 0x03;
13614#line 625 "rx-decode.opc"
13615                      int rdst AU = op[2] & 0x0f;
13616                      if (trace)
13617                        {
13618                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13619                                 "/** 1111 1101 0111 im00 0101rdst	min	#%1, %0 */",
13620                                 op[0], op[1], op[2]);
13621                          printf ("  im = 0x%x,", im);
13622                          printf ("  rdst = 0x%x\n", rdst);
13623                        }
13624                      SYNTAX("min	#%1, %0");
13625#line 625 "rx-decode.opc"
13626                      ID(min); DR(rdst); SC(IMMex(im));
13627
13628                    }
13629                  break;
13630                case 0x60:
13631                  op_semantics_116:
13632                    {
13633                      /** 1111 1101 0111 im00 0110rdst	emul	#%1, %0 */
13634#line 683 "rx-decode.opc"
13635                      int im AU = (op[1] >> 2) & 0x03;
13636#line 683 "rx-decode.opc"
13637                      int rdst AU = op[2] & 0x0f;
13638                      if (trace)
13639                        {
13640                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13641                                 "/** 1111 1101 0111 im00 0110rdst	emul	#%1, %0 */",
13642                                 op[0], op[1], op[2]);
13643                          printf ("  im = 0x%x,", im);
13644                          printf ("  rdst = 0x%x\n", rdst);
13645                        }
13646                      SYNTAX("emul	#%1, %0");
13647#line 683 "rx-decode.opc"
13648                      ID(emul); DR(rdst); SC(IMMex(im));
13649
13650                    }
13651                  break;
13652                case 0x70:
13653                  op_semantics_117:
13654                    {
13655                      /** 1111 1101 0111 im00 0111rdst	emulu	#%1, %0 */
13656#line 695 "rx-decode.opc"
13657                      int im AU = (op[1] >> 2) & 0x03;
13658#line 695 "rx-decode.opc"
13659                      int rdst AU = op[2] & 0x0f;
13660                      if (trace)
13661                        {
13662                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13663                                 "/** 1111 1101 0111 im00 0111rdst	emulu	#%1, %0 */",
13664                                 op[0], op[1], op[2]);
13665                          printf ("  im = 0x%x,", im);
13666                          printf ("  rdst = 0x%x\n", rdst);
13667                        }
13668                      SYNTAX("emulu	#%1, %0");
13669#line 695 "rx-decode.opc"
13670                      ID(emulu); DR(rdst); SC(IMMex(im));
13671
13672                    }
13673                  break;
13674                case 0x80:
13675                  op_semantics_118:
13676                    {
13677                      /** 1111 1101 0111 im00 1000rdst	div	#%1, %0 */
13678#line 707 "rx-decode.opc"
13679                      int im AU = (op[1] >> 2) & 0x03;
13680#line 707 "rx-decode.opc"
13681                      int rdst AU = op[2] & 0x0f;
13682                      if (trace)
13683                        {
13684                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13685                                 "/** 1111 1101 0111 im00 1000rdst	div	#%1, %0 */",
13686                                 op[0], op[1], op[2]);
13687                          printf ("  im = 0x%x,", im);
13688                          printf ("  rdst = 0x%x\n", rdst);
13689                        }
13690                      SYNTAX("div	#%1, %0");
13691#line 707 "rx-decode.opc"
13692                      ID(div); DR(rdst); SC(IMMex(im)); F_O___;
13693
13694                    }
13695                  break;
13696                case 0x90:
13697                  op_semantics_119:
13698                    {
13699                      /** 1111 1101 0111 im00 1001rdst	divu	#%1, %0 */
13700#line 719 "rx-decode.opc"
13701                      int im AU = (op[1] >> 2) & 0x03;
13702#line 719 "rx-decode.opc"
13703                      int rdst AU = op[2] & 0x0f;
13704                      if (trace)
13705                        {
13706                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13707                                 "/** 1111 1101 0111 im00 1001rdst	divu	#%1, %0 */",
13708                                 op[0], op[1], op[2]);
13709                          printf ("  im = 0x%x,", im);
13710                          printf ("  rdst = 0x%x\n", rdst);
13711                        }
13712                      SYNTAX("divu	#%1, %0");
13713#line 719 "rx-decode.opc"
13714                      ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
13715
13716                    }
13717                  break;
13718                case 0xc0:
13719                  op_semantics_120:
13720                    {
13721                      /** 1111 1101 0111 im00 1100rdst	tst	#%1, %2 */
13722#line 492 "rx-decode.opc"
13723                      int im AU = (op[1] >> 2) & 0x03;
13724#line 492 "rx-decode.opc"
13725                      int rdst AU = op[2] & 0x0f;
13726                      if (trace)
13727                        {
13728                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13729                                 "/** 1111 1101 0111 im00 1100rdst	tst	#%1, %2 */",
13730                                 op[0], op[1], op[2]);
13731                          printf ("  im = 0x%x,", im);
13732                          printf ("  rdst = 0x%x\n", rdst);
13733                        }
13734                      SYNTAX("tst	#%1, %2");
13735#line 492 "rx-decode.opc"
13736                      ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
13737
13738                    }
13739                  break;
13740                case 0xd0:
13741                  op_semantics_121:
13742                    {
13743                      /** 1111 1101 0111 im00 1101rdst	xor	#%1, %0 */
13744#line 471 "rx-decode.opc"
13745                      int im AU = (op[1] >> 2) & 0x03;
13746#line 471 "rx-decode.opc"
13747                      int rdst AU = op[2] & 0x0f;
13748                      if (trace)
13749                        {
13750                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13751                                 "/** 1111 1101 0111 im00 1101rdst	xor	#%1, %0 */",
13752                                 op[0], op[1], op[2]);
13753                          printf ("  im = 0x%x,", im);
13754                          printf ("  rdst = 0x%x\n", rdst);
13755                        }
13756                      SYNTAX("xor	#%1, %0");
13757#line 471 "rx-decode.opc"
13758                      ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
13759
13760                    }
13761                  break;
13762                case 0xe0:
13763                  op_semantics_122:
13764                    {
13765                      /** 1111 1101 0111 im00 1110rdst	stz	#%1, %0 */
13766#line 417 "rx-decode.opc"
13767                      int im AU = (op[1] >> 2) & 0x03;
13768#line 417 "rx-decode.opc"
13769                      int rdst AU = op[2] & 0x0f;
13770                      if (trace)
13771                        {
13772                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13773                                 "/** 1111 1101 0111 im00 1110rdst	stz	#%1, %0 */",
13774                                 op[0], op[1], op[2]);
13775                          printf ("  im = 0x%x,", im);
13776                          printf ("  rdst = 0x%x\n", rdst);
13777                        }
13778                      SYNTAX("stz	#%1, %0");
13779#line 417 "rx-decode.opc"
13780                      ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
13781
13782                    }
13783                  break;
13784                case 0xf0:
13785                  op_semantics_123:
13786                    {
13787                      /** 1111 1101 0111 im00 1111rdst	stnz	#%1, %0 */
13788#line 420 "rx-decode.opc"
13789                      int im AU = (op[1] >> 2) & 0x03;
13790#line 420 "rx-decode.opc"
13791                      int rdst AU = op[2] & 0x0f;
13792                      if (trace)
13793                        {
13794                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13795                                 "/** 1111 1101 0111 im00 1111rdst	stnz	#%1, %0 */",
13796                                 op[0], op[1], op[2]);
13797                          printf ("  im = 0x%x,", im);
13798                          printf ("  rdst = 0x%x\n", rdst);
13799                        }
13800                      SYNTAX("stnz	#%1, %0");
13801#line 420 "rx-decode.opc"
13802                      ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803
13804                    /*----------------------------------------------------------------------*/
13805                    /* RTSD									*/
13806
13807                    }
13808                  break;
13809                default: UNSUPPORTED(); break;
13810              }
13811            break;
13812          case 0x72:
13813              GETBYTE ();
13814              switch (op[2] & 0xf0)
13815              {
13816                case 0x00:
13817                    {
13818                      /** 1111 1101 0111 0010 0000 rdst	fsub	#%1, %0 */
13819#line 927 "rx-decode.opc"
13820                      int rdst AU = op[2] & 0x0f;
13821                      if (trace)
13822                        {
13823                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13824                                 "/** 1111 1101 0111 0010 0000 rdst	fsub	#%1, %0 */",
13825                                 op[0], op[1], op[2]);
13826                          printf ("  rdst = 0x%x\n", rdst);
13827                        }
13828                      SYNTAX("fsub	#%1, %0");
13829#line 927 "rx-decode.opc"
13830                      ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831
13832                    }
13833                  break;
13834                case 0x10:
13835                    {
13836                      /** 1111 1101 0111 0010 0001 rdst	fcmp	#%1, %0 */
13837#line 921 "rx-decode.opc"
13838                      int rdst AU = op[2] & 0x0f;
13839                      if (trace)
13840                        {
13841                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13842                                 "/** 1111 1101 0111 0010 0001 rdst	fcmp	#%1, %0 */",
13843                                 op[0], op[1], op[2]);
13844                          printf ("  rdst = 0x%x\n", rdst);
13845                        }
13846                      SYNTAX("fcmp	#%1, %0");
13847#line 921 "rx-decode.opc"
13848                      ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
13849
13850                    }
13851                  break;
13852                case 0x20:
13853                    {
13854                      /** 1111 1101 0111 0010 0010 rdst	fadd	#%1, %0 */
13855#line 915 "rx-decode.opc"
13856                      int rdst AU = op[2] & 0x0f;
13857                      if (trace)
13858                        {
13859                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13860                                 "/** 1111 1101 0111 0010 0010 rdst	fadd	#%1, %0 */",
13861                                 op[0], op[1], op[2]);
13862                          printf ("  rdst = 0x%x\n", rdst);
13863                        }
13864                      SYNTAX("fadd	#%1, %0");
13865#line 915 "rx-decode.opc"
13866                      ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
13867
13868                    }
13869                  break;
13870                case 0x30:
13871                    {
13872                      /** 1111 1101 0111 0010 0011 rdst	fmul	#%1, %0 */
13873#line 936 "rx-decode.opc"
13874                      int rdst AU = op[2] & 0x0f;
13875                      if (trace)
13876                        {
13877                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13878                                 "/** 1111 1101 0111 0010 0011 rdst	fmul	#%1, %0 */",
13879                                 op[0], op[1], op[2]);
13880                          printf ("  rdst = 0x%x\n", rdst);
13881                        }
13882                      SYNTAX("fmul	#%1, %0");
13883#line 936 "rx-decode.opc"
13884                      ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
13885
13886                    }
13887                  break;
13888                case 0x40:
13889                    {
13890                      /** 1111 1101 0111 0010 0100 rdst	fdiv	#%1, %0 */
13891#line 942 "rx-decode.opc"
13892                      int rdst AU = op[2] & 0x0f;
13893                      if (trace)
13894                        {
13895                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13896                                 "/** 1111 1101 0111 0010 0100 rdst	fdiv	#%1, %0 */",
13897                                 op[0], op[1], op[2]);
13898                          printf ("  rdst = 0x%x\n", rdst);
13899                        }
13900                      SYNTAX("fdiv	#%1, %0");
13901#line 942 "rx-decode.opc"
13902                      ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
13903
13904                    }
13905                  break;
13906                default: UNSUPPORTED(); break;
13907              }
13908            break;
13909          case 0x73:
13910              GETBYTE ();
13911              switch (op[2] & 0xe0)
13912              {
13913                case 0x00:
13914                  op_semantics_124:
13915                    {
13916                      /** 1111 1101 0111 im11 000crdst	mvtc	#%1, %0 */
13917#line 1032 "rx-decode.opc"
13918                      int im AU = (op[1] >> 2) & 0x03;
13919#line 1032 "rx-decode.opc"
13920                      int crdst AU = op[2] & 0x1f;
13921                      if (trace)
13922                        {
13923                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13924                                 "/** 1111 1101 0111 im11 000crdst	mvtc	#%1, %0 */",
13925                                 op[0], op[1], op[2]);
13926                          printf ("  im = 0x%x,", im);
13927                          printf ("  crdst = 0x%x\n", crdst);
13928                        }
13929                      SYNTAX("mvtc	#%1, %0");
13930#line 1032 "rx-decode.opc"
13931                      ID(mov); SC(IMMex(im)); DR(crdst + 16);
13932
13933                    }
13934                  break;
13935                default: UNSUPPORTED(); break;
13936              }
13937            break;
13938          case 0x74:
13939              GETBYTE ();
13940              switch (op[2] & 0xf0)
13941              {
13942                case 0x20:
13943                  goto op_semantics_113;
13944                  break;
13945                case 0x40:
13946                  goto op_semantics_114;
13947                  break;
13948                case 0x50:
13949                  goto op_semantics_115;
13950                  break;
13951                case 0x60:
13952                  goto op_semantics_116;
13953                  break;
13954                case 0x70:
13955                  goto op_semantics_117;
13956                  break;
13957                case 0x80:
13958                  goto op_semantics_118;
13959                  break;
13960                case 0x90:
13961                  goto op_semantics_119;
13962                  break;
13963                case 0xc0:
13964                  goto op_semantics_120;
13965                  break;
13966                case 0xd0:
13967                  goto op_semantics_121;
13968                  break;
13969                case 0xe0:
13970                  goto op_semantics_122;
13971                  break;
13972                case 0xf0:
13973                  goto op_semantics_123;
13974                  break;
13975                default: UNSUPPORTED(); break;
13976              }
13977            break;
13978          case 0x75:
13979              GETBYTE ();
13980              switch (op[2] & 0xff)
13981              {
13982                case 0x80:
13983                    GETBYTE ();
13984                    switch (op[3] & 0x0f)
13985                    {
13986                      case 0x00:
13987                        op_semantics_125:
13988                          {
13989                            /** 1111 1101 0111 0101 1000 rdst rsrc 0000	dmov.l	%1, %0 */
13990#line 1176 "rx-decode.opc"
13991                            int rdst AU = op[2] & 0x0f;
13992#line 1176 "rx-decode.opc"
13993                            int rsrc AU = (op[3] >> 4) & 0x0f;
13994                            if (trace)
13995                              {
13996                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
13997                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0000	dmov.l	%1, %0 */",
13998                                       op[0], op[1], op[2], op[3]);
13999                                printf ("  rdst = 0x%x,", rdst);
14000                                printf ("  rsrc = 0x%x\n", rsrc);
14001                              }
14002                            SYNTAX("dmov.l	%1, %0");
14003#line 1176 "rx-decode.opc"
14004                            ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005
14006                          }
14007                        break;
14008                      case 0x02:
14009                        op_semantics_126:
14010                          {
14011                            /** 1111 1101 0111 0101 1000 rdst rsrc 0010	dmov.l	%1, %0 */
14012#line 1173 "rx-decode.opc"
14013                            int rdst AU = op[2] & 0x0f;
14014#line 1173 "rx-decode.opc"
14015                            int rsrc AU = (op[3] >> 4) & 0x0f;
14016                            if (trace)
14017                              {
14018                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14019                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0010	dmov.l	%1, %0 */",
14020                                       op[0], op[1], op[2], op[3]);
14021                                printf ("  rdst = 0x%x,", rdst);
14022                                printf ("  rsrc = 0x%x\n", rsrc);
14023                              }
14024                            SYNTAX("dmov.l	%1, %0");
14025#line 1173 "rx-decode.opc"
14026                            ID(dmov); DR(rdst); SDRH(rsrc); F_____;
14027
14028                          }
14029                        break;
14030                      case 0x04:
14031                        op_semantics_127:
14032                          {
14033                            /** 1111 1101 0111 0101 1000 rdst rsrc 0100	mvfdc	%1, %0 */
14034#line 1226 "rx-decode.opc"
14035                            int rdst AU = op[2] & 0x0f;
14036#line 1226 "rx-decode.opc"
14037                            int rsrc AU = (op[3] >> 4) & 0x0f;
14038                            if (trace)
14039                              {
14040                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14041                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0100	mvfdc	%1, %0 */",
14042                                       op[0], op[1], op[2], op[3]);
14043                                printf ("  rdst = 0x%x,", rdst);
14044                                printf ("  rsrc = 0x%x\n", rsrc);
14045                              }
14046                            SYNTAX("mvfdc	%1, %0");
14047#line 1226 "rx-decode.opc"
14048                            ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049
14050                          }
14051                        break;
14052                      default: UNSUPPORTED(); break;
14053                    }
14054                  break;
14055                case 0x81:
14056                    GETBYTE ();
14057                    switch (op[3] & 0x0f)
14058                    {
14059                      case 0x00:
14060                        goto op_semantics_125;
14061                        break;
14062                      case 0x02:
14063                        goto op_semantics_126;
14064                        break;
14065                      case 0x04:
14066                        goto op_semantics_127;
14067                        break;
14068                      default: UNSUPPORTED(); break;
14069                    }
14070                  break;
14071                case 0x82:
14072                    GETBYTE ();
14073                    switch (op[3] & 0x0f)
14074                    {
14075                      case 0x00:
14076                        goto op_semantics_125;
14077                        break;
14078                      case 0x02:
14079                        goto op_semantics_126;
14080                        break;
14081                      case 0x04:
14082                        goto op_semantics_127;
14083                        break;
14084                      default: UNSUPPORTED(); break;
14085                    }
14086                  break;
14087                case 0x83:
14088                    GETBYTE ();
14089                    switch (op[3] & 0x0f)
14090                    {
14091                      case 0x00:
14092                        goto op_semantics_125;
14093                        break;
14094                      case 0x02:
14095                        goto op_semantics_126;
14096                        break;
14097                      case 0x04:
14098                        goto op_semantics_127;
14099                        break;
14100                      default: UNSUPPORTED(); break;
14101                    }
14102                  break;
14103                case 0x84:
14104                    GETBYTE ();
14105                    switch (op[3] & 0x0f)
14106                    {
14107                      case 0x00:
14108                        goto op_semantics_125;
14109                        break;
14110                      case 0x02:
14111                        goto op_semantics_126;
14112                        break;
14113                      case 0x04:
14114                        goto op_semantics_127;
14115                        break;
14116                      default: UNSUPPORTED(); break;
14117                    }
14118                  break;
14119                case 0x85:
14120                    GETBYTE ();
14121                    switch (op[3] & 0x0f)
14122                    {
14123                      case 0x00:
14124                        goto op_semantics_125;
14125                        break;
14126                      case 0x02:
14127                        goto op_semantics_126;
14128                        break;
14129                      case 0x04:
14130                        goto op_semantics_127;
14131                        break;
14132                      default: UNSUPPORTED(); break;
14133                    }
14134                  break;
14135                case 0x86:
14136                    GETBYTE ();
14137                    switch (op[3] & 0x0f)
14138                    {
14139                      case 0x00:
14140                        goto op_semantics_125;
14141                        break;
14142                      case 0x02:
14143                        goto op_semantics_126;
14144                        break;
14145                      case 0x04:
14146                        goto op_semantics_127;
14147                        break;
14148                      default: UNSUPPORTED(); break;
14149                    }
14150                  break;
14151                case 0x87:
14152                    GETBYTE ();
14153                    switch (op[3] & 0x0f)
14154                    {
14155                      case 0x00:
14156                        goto op_semantics_125;
14157                        break;
14158                      case 0x02:
14159                        goto op_semantics_126;
14160                        break;
14161                      case 0x04:
14162                        goto op_semantics_127;
14163                        break;
14164                      default: UNSUPPORTED(); break;
14165                    }
14166                  break;
14167                case 0x88:
14168                    GETBYTE ();
14169                    switch (op[3] & 0x0f)
14170                    {
14171                      case 0x00:
14172                        goto op_semantics_125;
14173                        break;
14174                      case 0x02:
14175                        goto op_semantics_126;
14176                        break;
14177                      case 0x04:
14178                        goto op_semantics_127;
14179                        break;
14180                      default: UNSUPPORTED(); break;
14181                    }
14182                  break;
14183                case 0x89:
14184                    GETBYTE ();
14185                    switch (op[3] & 0x0f)
14186                    {
14187                      case 0x00:
14188                        goto op_semantics_125;
14189                        break;
14190                      case 0x02:
14191                        goto op_semantics_126;
14192                        break;
14193                      case 0x04:
14194                        goto op_semantics_127;
14195                        break;
14196                      default: UNSUPPORTED(); break;
14197                    }
14198                  break;
14199                case 0x8a:
14200                    GETBYTE ();
14201                    switch (op[3] & 0x0f)
14202                    {
14203                      case 0x00:
14204                        goto op_semantics_125;
14205                        break;
14206                      case 0x02:
14207                        goto op_semantics_126;
14208                        break;
14209                      case 0x04:
14210                        goto op_semantics_127;
14211                        break;
14212                      default: UNSUPPORTED(); break;
14213                    }
14214                  break;
14215                case 0x8b:
14216                    GETBYTE ();
14217                    switch (op[3] & 0x0f)
14218                    {
14219                      case 0x00:
14220                        goto op_semantics_125;
14221                        break;
14222                      case 0x02:
14223                        goto op_semantics_126;
14224                        break;
14225                      case 0x04:
14226                        goto op_semantics_127;
14227                        break;
14228                      default: UNSUPPORTED(); break;
14229                    }
14230                  break;
14231                case 0x8c:
14232                    GETBYTE ();
14233                    switch (op[3] & 0x0f)
14234                    {
14235                      case 0x00:
14236                        goto op_semantics_125;
14237                        break;
14238                      case 0x02:
14239                        goto op_semantics_126;
14240                        break;
14241                      case 0x04:
14242                        goto op_semantics_127;
14243                        break;
14244                      default: UNSUPPORTED(); break;
14245                    }
14246                  break;
14247                case 0x8d:
14248                    GETBYTE ();
14249                    switch (op[3] & 0x0f)
14250                    {
14251                      case 0x00:
14252                        goto op_semantics_125;
14253                        break;
14254                      case 0x02:
14255                        goto op_semantics_126;
14256                        break;
14257                      case 0x04:
14258                        goto op_semantics_127;
14259                        break;
14260                      default: UNSUPPORTED(); break;
14261                    }
14262                  break;
14263                case 0x8e:
14264                    GETBYTE ();
14265                    switch (op[3] & 0x0f)
14266                    {
14267                      case 0x00:
14268                        goto op_semantics_125;
14269                        break;
14270                      case 0x02:
14271                        goto op_semantics_126;
14272                        break;
14273                      case 0x04:
14274                        goto op_semantics_127;
14275                        break;
14276                      default: UNSUPPORTED(); break;
14277                    }
14278                  break;
14279                case 0x8f:
14280                    GETBYTE ();
14281                    switch (op[3] & 0x0f)
14282                    {
14283                      case 0x00:
14284                        goto op_semantics_125;
14285                        break;
14286                      case 0x02:
14287                        goto op_semantics_126;
14288                        break;
14289                      case 0x04:
14290                        goto op_semantics_127;
14291                        break;
14292                      default: UNSUPPORTED(); break;
14293                    }
14294                  break;
14295                default: UNSUPPORTED(); break;
14296              }
14297            break;
14298          case 0x76:
14299              GETBYTE ();
14300              switch (op[2] & 0xff)
14301              {
14302                case 0xc0:
14303                    GETBYTE ();
14304                    switch (op[3] & 0xff)
14305                    {
14306                      case 0x00:
14307                        op_semantics_128:
14308                          {
14309                            /** 1111 1101 0111 0110 1100 rsrc 0000 0000 	save	%1 */
14310#line 1161 "rx-decode.opc"
14311                            int rsrc AU = op[2] & 0x0f;
14312                            if (trace)
14313                              {
14314                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14315                                       "/** 1111 1101 0111 0110 1100 rsrc 0000 0000 	save	%1 */",
14316                                       op[0], op[1], op[2], op[3]);
14317                                printf ("  rsrc = 0x%x\n", rsrc);
14318                              }
14319                            SYNTAX("save	%1");
14320#line 1161 "rx-decode.opc"
14321                            ID(save); SR(rsrc); F_____;
14322
14323                          }
14324                        break;
14325                      default: UNSUPPORTED(); break;
14326                    }
14327                  break;
14328                case 0xc1:
14329                    GETBYTE ();
14330                    switch (op[3] & 0xff)
14331                    {
14332                      case 0x00:
14333                        goto op_semantics_128;
14334                        break;
14335                      default: UNSUPPORTED(); break;
14336                    }
14337                  break;
14338                case 0xc2:
14339                    GETBYTE ();
14340                    switch (op[3] & 0xff)
14341                    {
14342                      case 0x00:
14343                        goto op_semantics_128;
14344                        break;
14345                      default: UNSUPPORTED(); break;
14346                    }
14347                  break;
14348                case 0xc3:
14349                    GETBYTE ();
14350                    switch (op[3] & 0xff)
14351                    {
14352                      case 0x00:
14353                        goto op_semantics_128;
14354                        break;
14355                      default: UNSUPPORTED(); break;
14356                    }
14357                  break;
14358                case 0xc4:
14359                    GETBYTE ();
14360                    switch (op[3] & 0xff)
14361                    {
14362                      case 0x00:
14363                        goto op_semantics_128;
14364                        break;
14365                      default: UNSUPPORTED(); break;
14366                    }
14367                  break;
14368                case 0xc5:
14369                    GETBYTE ();
14370                    switch (op[3] & 0xff)
14371                    {
14372                      case 0x00:
14373                        goto op_semantics_128;
14374                        break;
14375                      default: UNSUPPORTED(); break;
14376                    }
14377                  break;
14378                case 0xc6:
14379                    GETBYTE ();
14380                    switch (op[3] & 0xff)
14381                    {
14382                      case 0x00:
14383                        goto op_semantics_128;
14384                        break;
14385                      default: UNSUPPORTED(); break;
14386                    }
14387                  break;
14388                case 0xc7:
14389                    GETBYTE ();
14390                    switch (op[3] & 0xff)
14391                    {
14392                      case 0x00:
14393                        goto op_semantics_128;
14394                        break;
14395                      default: UNSUPPORTED(); break;
14396                    }
14397                  break;
14398                case 0xc8:
14399                    GETBYTE ();
14400                    switch (op[3] & 0xff)
14401                    {
14402                      case 0x00:
14403                        goto op_semantics_128;
14404                        break;
14405                      default: UNSUPPORTED(); break;
14406                    }
14407                  break;
14408                case 0xc9:
14409                    GETBYTE ();
14410                    switch (op[3] & 0xff)
14411                    {
14412                      case 0x00:
14413                        goto op_semantics_128;
14414                        break;
14415                      default: UNSUPPORTED(); break;
14416                    }
14417                  break;
14418                case 0xca:
14419                    GETBYTE ();
14420                    switch (op[3] & 0xff)
14421                    {
14422                      case 0x00:
14423                        goto op_semantics_128;
14424                        break;
14425                      default: UNSUPPORTED(); break;
14426                    }
14427                  break;
14428                case 0xcb:
14429                    GETBYTE ();
14430                    switch (op[3] & 0xff)
14431                    {
14432                      case 0x00:
14433                        goto op_semantics_128;
14434                        break;
14435                      default: UNSUPPORTED(); break;
14436                    }
14437                  break;
14438                case 0xcc:
14439                    GETBYTE ();
14440                    switch (op[3] & 0xff)
14441                    {
14442                      case 0x00:
14443                        goto op_semantics_128;
14444                        break;
14445                      default: UNSUPPORTED(); break;
14446                    }
14447                  break;
14448                case 0xcd:
14449                    GETBYTE ();
14450                    switch (op[3] & 0xff)
14451                    {
14452                      case 0x00:
14453                        goto op_semantics_128;
14454                        break;
14455                      default: UNSUPPORTED(); break;
14456                    }
14457                  break;
14458                case 0xce:
14459                    GETBYTE ();
14460                    switch (op[3] & 0xff)
14461                    {
14462                      case 0x00:
14463                        goto op_semantics_128;
14464                        break;
14465                      default: UNSUPPORTED(); break;
14466                    }
14467                  break;
14468                case 0xcf:
14469                    GETBYTE ();
14470                    switch (op[3] & 0xff)
14471                    {
14472                      case 0x00:
14473                        goto op_semantics_128;
14474                        break;
14475                      default: UNSUPPORTED(); break;
14476                    }
14477                  break;
14478                case 0xd0:
14479                    GETBYTE ();
14480                    switch (op[3] & 0xff)
14481                    {
14482                      case 0x00:
14483                        op_semantics_129:
14484                          {
14485                            /** 1111 1101 0111 0110 1101 rsrc 0000 0000 	rstr	%1 */
14486#line 1155 "rx-decode.opc"
14487                            int rsrc AU = op[2] & 0x0f;
14488                            if (trace)
14489                              {
14490                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14491                                       "/** 1111 1101 0111 0110 1101 rsrc 0000 0000 	rstr	%1 */",
14492                                       op[0], op[1], op[2], op[3]);
14493                                printf ("  rsrc = 0x%x\n", rsrc);
14494                              }
14495                            SYNTAX("rstr	%1");
14496#line 1155 "rx-decode.opc"
14497                            ID(rstr); SR(rsrc); F_____;
14498
14499                          }
14500                        break;
14501                      default: UNSUPPORTED(); break;
14502                    }
14503                  break;
14504                case 0xd1:
14505                    GETBYTE ();
14506                    switch (op[3] & 0xff)
14507                    {
14508                      case 0x00:
14509                        goto op_semantics_129;
14510                        break;
14511                      default: UNSUPPORTED(); break;
14512                    }
14513                  break;
14514                case 0xd2:
14515                    GETBYTE ();
14516                    switch (op[3] & 0xff)
14517                    {
14518                      case 0x00:
14519                        goto op_semantics_129;
14520                        break;
14521                      default: UNSUPPORTED(); break;
14522                    }
14523                  break;
14524                case 0xd3:
14525                    GETBYTE ();
14526                    switch (op[3] & 0xff)
14527                    {
14528                      case 0x00:
14529                        goto op_semantics_129;
14530                        break;
14531                      default: UNSUPPORTED(); break;
14532                    }
14533                  break;
14534                case 0xd4:
14535                    GETBYTE ();
14536                    switch (op[3] & 0xff)
14537                    {
14538                      case 0x00:
14539                        goto op_semantics_129;
14540                        break;
14541                      default: UNSUPPORTED(); break;
14542                    }
14543                  break;
14544                case 0xd5:
14545                    GETBYTE ();
14546                    switch (op[3] & 0xff)
14547                    {
14548                      case 0x00:
14549                        goto op_semantics_129;
14550                        break;
14551                      default: UNSUPPORTED(); break;
14552                    }
14553                  break;
14554                case 0xd6:
14555                    GETBYTE ();
14556                    switch (op[3] & 0xff)
14557                    {
14558                      case 0x00:
14559                        goto op_semantics_129;
14560                        break;
14561                      default: UNSUPPORTED(); break;
14562                    }
14563                  break;
14564                case 0xd7:
14565                    GETBYTE ();
14566                    switch (op[3] & 0xff)
14567                    {
14568                      case 0x00:
14569                        goto op_semantics_129;
14570                        break;
14571                      default: UNSUPPORTED(); break;
14572                    }
14573                  break;
14574                case 0xd8:
14575                    GETBYTE ();
14576                    switch (op[3] & 0xff)
14577                    {
14578                      case 0x00:
14579                        goto op_semantics_129;
14580                        break;
14581                      default: UNSUPPORTED(); break;
14582                    }
14583                  break;
14584                case 0xd9:
14585                    GETBYTE ();
14586                    switch (op[3] & 0xff)
14587                    {
14588                      case 0x00:
14589                        goto op_semantics_129;
14590                        break;
14591                      default: UNSUPPORTED(); break;
14592                    }
14593                  break;
14594                case 0xda:
14595                    GETBYTE ();
14596                    switch (op[3] & 0xff)
14597                    {
14598                      case 0x00:
14599                        goto op_semantics_129;
14600                        break;
14601                      default: UNSUPPORTED(); break;
14602                    }
14603                  break;
14604                case 0xdb:
14605                    GETBYTE ();
14606                    switch (op[3] & 0xff)
14607                    {
14608                      case 0x00:
14609                        goto op_semantics_129;
14610                        break;
14611                      default: UNSUPPORTED(); break;
14612                    }
14613                  break;
14614                case 0xdc:
14615                    GETBYTE ();
14616                    switch (op[3] & 0xff)
14617                    {
14618                      case 0x00:
14619                        goto op_semantics_129;
14620                        break;
14621                      default: UNSUPPORTED(); break;
14622                    }
14623                  break;
14624                case 0xdd:
14625                    GETBYTE ();
14626                    switch (op[3] & 0xff)
14627                    {
14628                      case 0x00:
14629                        goto op_semantics_129;
14630                        break;
14631                      default: UNSUPPORTED(); break;
14632                    }
14633                  break;
14634                case 0xde:
14635                    GETBYTE ();
14636                    switch (op[3] & 0xff)
14637                    {
14638                      case 0x00:
14639                        goto op_semantics_129;
14640                        break;
14641                      default: UNSUPPORTED(); break;
14642                    }
14643                  break;
14644                case 0xdf:
14645                    GETBYTE ();
14646                    switch (op[3] & 0xff)
14647                    {
14648                      case 0x00:
14649                        goto op_semantics_129;
14650                        break;
14651                      default: UNSUPPORTED(); break;
14652                    }
14653                  break;
14654                case 0xe0:
14655                    {
14656                      /** 1111 1101 0111 0110 1110 0000	save	#%1 */
14657                      if (trace)
14658                        {
14659                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14660                                 "/** 1111 1101 0111 0110 1110 0000	save	#%1 */",
14661                                 op[0], op[1], op[2]);
14662                        }
14663                      SYNTAX("save	#%1");
14664#line 1164 "rx-decode.opc"
14665                      ID(save); SC(IMM(1)); F_____;
14666
14667                    }
14668                  break;
14669                case 0xf0:
14670                    {
14671                      /** 1111 1101 0111 0110 1111 0000 	rstr	#%1 */
14672                      if (trace)
14673                        {
14674                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14675                                 "/** 1111 1101 0111 0110 1111 0000 	rstr	#%1 */",
14676                                 op[0], op[1], op[2]);
14677                        }
14678                      SYNTAX("rstr	#%1");
14679#line 1158 "rx-decode.opc"
14680                      ID(rstr); SC(IMM(1)); F_____;
14681
14682                    }
14683                  break;
14684                default: UNSUPPORTED(); break;
14685              }
14686            break;
14687          case 0x77:
14688              GETBYTE ();
14689              switch (op[2] & 0xff)
14690              {
14691                case 0x00:
14692                case 0x01:
14693                case 0x02:
14694                case 0x03:
14695                case 0x04:
14696                case 0x05:
14697                case 0x06:
14698                case 0x07:
14699                case 0x08:
14700                case 0x09:
14701                case 0x0a:
14702                case 0x0b:
14703                case 0x0c:
14704                case 0x0d:
14705                case 0x0e:
14706                case 0x0f:
14707                case 0x10:
14708                case 0x11:
14709                case 0x12:
14710                case 0x13:
14711                case 0x14:
14712                case 0x15:
14713                case 0x16:
14714                case 0x17:
14715                case 0x18:
14716                case 0x19:
14717                case 0x1a:
14718                case 0x1b:
14719                case 0x1c:
14720                case 0x1d:
14721                case 0x1e:
14722                case 0x1f:
14723                  goto op_semantics_124;
14724                  break;
14725                case 0x80:
14726                    GETBYTE ();
14727                    switch (op[3] & 0x0f)
14728                    {
14729                      case 0x00:
14730                        op_semantics_130:
14731                          {
14732                            /** 1111 1101 0111 0111 1000 rsrc rdst 0000	dmov.l	%1, %0 */
14733#line 1170 "rx-decode.opc"
14734                            int rsrc AU = op[2] & 0x0f;
14735#line 1170 "rx-decode.opc"
14736                            int rdst AU = (op[3] >> 4) & 0x0f;
14737                            if (trace)
14738                              {
14739                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14740                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 0000	dmov.l	%1, %0 */",
14741                                       op[0], op[1], op[2], op[3]);
14742                                printf ("  rsrc = 0x%x,", rsrc);
14743                                printf ("  rdst = 0x%x\n", rdst);
14744                              }
14745                            SYNTAX("dmov.l	%1, %0");
14746#line 1170 "rx-decode.opc"
14747                            ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748
14749                          }
14750                        break;
14751                      case 0x02:
14752                      case 0x03:
14753                        op_semantics_131:
14754                          {
14755                            /** 1111 1101 0111 0111 1000 rsrc rdst 001s	dmov%s	%1, %0 */
14756#line 1167 "rx-decode.opc"
14757                            int rsrc AU = op[2] & 0x0f;
14758#line 1167 "rx-decode.opc"
14759                            int rdst AU = (op[3] >> 4) & 0x0f;
14760#line 1167 "rx-decode.opc"
14761                            int s AU = op[3] & 0x01;
14762                            if (trace)
14763                              {
14764                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14765                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 001s	dmov%s	%1, %0 */",
14766                                       op[0], op[1], op[2], op[3]);
14767                                printf ("  rsrc = 0x%x,", rsrc);
14768                                printf ("  rdst = 0x%x,", rdst);
14769                                printf ("  s = 0x%x\n", s);
14770                              }
14771                            SYNTAX("dmov%s	%1, %0");
14772#line 1167 "rx-decode.opc"
14773                            ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774
14775                          }
14776                        break;
14777                      case 0x04:
14778                        op_semantics_132:
14779                          {
14780                            /** 1111 1101 0111 0111 1000 rdst rsrc 0100	mvtdc	%1, %0 */
14781#line 1232 "rx-decode.opc"
14782                            int rdst AU = op[2] & 0x0f;
14783#line 1232 "rx-decode.opc"
14784                            int rsrc AU = (op[3] >> 4) & 0x0f;
14785                            if (trace)
14786                              {
14787                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14788                                       "/** 1111 1101 0111 0111 1000 rdst rsrc 0100	mvtdc	%1, %0 */",
14789                                       op[0], op[1], op[2], op[3]);
14790                                printf ("  rdst = 0x%x,", rdst);
14791                                printf ("  rsrc = 0x%x\n", rsrc);
14792                              }
14793                            SYNTAX("mvtdc	%1, %0");
14794#line 1232 "rx-decode.opc"
14795                            ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796
14797                          }
14798                        break;
14799                      case 0x09:
14800                        op_semantics_133:
14801                          {
14802                            /** 1111 1101 0111 0111 1000 rsrc rdst 1001	itod	%1, %0 */
14803#line 1274 "rx-decode.opc"
14804                            int rsrc AU = op[2] & 0x0f;
14805#line 1274 "rx-decode.opc"
14806                            int rdst AU = (op[3] >> 4) & 0x0f;
14807                            if (trace)
14808                              {
14809                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14810                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1001	itod	%1, %0 */",
14811                                       op[0], op[1], op[2], op[3]);
14812                                printf ("  rsrc = 0x%x,", rsrc);
14813                                printf ("  rdst = 0x%x\n", rdst);
14814                              }
14815                            SYNTAX("itod	%1, %0");
14816#line 1274 "rx-decode.opc"
14817                            ID(itod); DDR(rdst); SR(rsrc); F_____;
14818
14819                          }
14820                        break;
14821                      case 0x0a:
14822                        op_semantics_134:
14823                          {
14824                            /** 1111 1101 0111 0111 1000 rsrc rdst 1010	ftod	%1, %0 */
14825#line 1271 "rx-decode.opc"
14826                            int rsrc AU = op[2] & 0x0f;
14827#line 1271 "rx-decode.opc"
14828                            int rdst AU = (op[3] >> 4) & 0x0f;
14829                            if (trace)
14830                              {
14831                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14832                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1010	ftod	%1, %0 */",
14833                                       op[0], op[1], op[2], op[3]);
14834                                printf ("  rsrc = 0x%x,", rsrc);
14835                                printf ("  rdst = 0x%x\n", rdst);
14836                              }
14837                            SYNTAX("ftod	%1, %0");
14838#line 1271 "rx-decode.opc"
14839                            ID(ftod); DDR(rdst); SR(rsrc); F_____;
14840
14841                          }
14842                        break;
14843                      case 0x0d:
14844                        op_semantics_135:
14845                          {
14846                            /** 1111 1101 0111 0111 1000 rsrc rdst 1101	utod	%1, %0 */
14847#line 1277 "rx-decode.opc"
14848                            int rsrc AU = op[2] & 0x0f;
14849#line 1277 "rx-decode.opc"
14850                            int rdst AU = (op[3] >> 4) & 0x0f;
14851                            if (trace)
14852                              {
14853                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14854                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1101	utod	%1, %0 */",
14855                                       op[0], op[1], op[2], op[3]);
14856                                printf ("  rsrc = 0x%x,", rsrc);
14857                                printf ("  rdst = 0x%x\n", rdst);
14858                              }
14859                            SYNTAX("utod	%1, %0");
14860#line 1277 "rx-decode.opc"
14861                            ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
14862
14863                          }
14864                        break;
14865                      default: UNSUPPORTED(); break;
14866                    }
14867                  break;
14868                case 0x81:
14869                    GETBYTE ();
14870                    switch (op[3] & 0x0f)
14871                    {
14872                      case 0x00:
14873                        goto op_semantics_130;
14874                        break;
14875                      case 0x02:
14876                      case 0x03:
14877                        goto op_semantics_131;
14878                        break;
14879                      case 0x04:
14880                        goto op_semantics_132;
14881                        break;
14882                      case 0x09:
14883                        goto op_semantics_133;
14884                        break;
14885                      case 0x0a:
14886                        goto op_semantics_134;
14887                        break;
14888                      case 0x0d:
14889                        goto op_semantics_135;
14890                        break;
14891                      default: UNSUPPORTED(); break;
14892                    }
14893                  break;
14894                case 0x82:
14895                    GETBYTE ();
14896                    switch (op[3] & 0x0f)
14897                    {
14898                      case 0x00:
14899                        goto op_semantics_130;
14900                        break;
14901                      case 0x02:
14902                      case 0x03:
14903                        goto op_semantics_131;
14904                        break;
14905                      case 0x04:
14906                        goto op_semantics_132;
14907                        break;
14908                      case 0x09:
14909                        goto op_semantics_133;
14910                        break;
14911                      case 0x0a:
14912                        goto op_semantics_134;
14913                        break;
14914                      case 0x0d:
14915                        goto op_semantics_135;
14916                        break;
14917                      default: UNSUPPORTED(); break;
14918                    }
14919                  break;
14920                case 0x83:
14921                    GETBYTE ();
14922                    switch (op[3] & 0x0f)
14923                    {
14924                      case 0x00:
14925                        goto op_semantics_130;
14926                        break;
14927                      case 0x02:
14928                      case 0x03:
14929                        goto op_semantics_131;
14930                        break;
14931                      case 0x04:
14932                        goto op_semantics_132;
14933                        break;
14934                      case 0x09:
14935                        goto op_semantics_133;
14936                        break;
14937                      case 0x0a:
14938                        goto op_semantics_134;
14939                        break;
14940                      case 0x0d:
14941                        goto op_semantics_135;
14942                        break;
14943                      default: UNSUPPORTED(); break;
14944                    }
14945                  break;
14946                case 0x84:
14947                    GETBYTE ();
14948                    switch (op[3] & 0x0f)
14949                    {
14950                      case 0x00:
14951                        goto op_semantics_130;
14952                        break;
14953                      case 0x02:
14954                      case 0x03:
14955                        goto op_semantics_131;
14956                        break;
14957                      case 0x04:
14958                        goto op_semantics_132;
14959                        break;
14960                      case 0x09:
14961                        goto op_semantics_133;
14962                        break;
14963                      case 0x0a:
14964                        goto op_semantics_134;
14965                        break;
14966                      case 0x0d:
14967                        goto op_semantics_135;
14968                        break;
14969                      default: UNSUPPORTED(); break;
14970                    }
14971                  break;
14972                case 0x85:
14973                    GETBYTE ();
14974                    switch (op[3] & 0x0f)
14975                    {
14976                      case 0x00:
14977                        goto op_semantics_130;
14978                        break;
14979                      case 0x02:
14980                      case 0x03:
14981                        goto op_semantics_131;
14982                        break;
14983                      case 0x04:
14984                        goto op_semantics_132;
14985                        break;
14986                      case 0x09:
14987                        goto op_semantics_133;
14988                        break;
14989                      case 0x0a:
14990                        goto op_semantics_134;
14991                        break;
14992                      case 0x0d:
14993                        goto op_semantics_135;
14994                        break;
14995                      default: UNSUPPORTED(); break;
14996                    }
14997                  break;
14998                case 0x86:
14999                    GETBYTE ();
15000                    switch (op[3] & 0x0f)
15001                    {
15002                      case 0x00:
15003                        goto op_semantics_130;
15004                        break;
15005                      case 0x02:
15006                      case 0x03:
15007                        goto op_semantics_131;
15008                        break;
15009                      case 0x04:
15010                        goto op_semantics_132;
15011                        break;
15012                      case 0x09:
15013                        goto op_semantics_133;
15014                        break;
15015                      case 0x0a:
15016                        goto op_semantics_134;
15017                        break;
15018                      case 0x0d:
15019                        goto op_semantics_135;
15020                        break;
15021                      default: UNSUPPORTED(); break;
15022                    }
15023                  break;
15024                case 0x87:
15025                    GETBYTE ();
15026                    switch (op[3] & 0x0f)
15027                    {
15028                      case 0x00:
15029                        goto op_semantics_130;
15030                        break;
15031                      case 0x02:
15032                      case 0x03:
15033                        goto op_semantics_131;
15034                        break;
15035                      case 0x04:
15036                        goto op_semantics_132;
15037                        break;
15038                      case 0x09:
15039                        goto op_semantics_133;
15040                        break;
15041                      case 0x0a:
15042                        goto op_semantics_134;
15043                        break;
15044                      case 0x0d:
15045                        goto op_semantics_135;
15046                        break;
15047                      default: UNSUPPORTED(); break;
15048                    }
15049                  break;
15050                case 0x88:
15051                    GETBYTE ();
15052                    switch (op[3] & 0x0f)
15053                    {
15054                      case 0x00:
15055                        goto op_semantics_130;
15056                        break;
15057                      case 0x02:
15058                      case 0x03:
15059                        goto op_semantics_131;
15060                        break;
15061                      case 0x04:
15062                        goto op_semantics_132;
15063                        break;
15064                      case 0x09:
15065                        goto op_semantics_133;
15066                        break;
15067                      case 0x0a:
15068                        goto op_semantics_134;
15069                        break;
15070                      case 0x0d:
15071                        goto op_semantics_135;
15072                        break;
15073                      default: UNSUPPORTED(); break;
15074                    }
15075                  break;
15076                case 0x89:
15077                    GETBYTE ();
15078                    switch (op[3] & 0x0f)
15079                    {
15080                      case 0x00:
15081                        goto op_semantics_130;
15082                        break;
15083                      case 0x02:
15084                      case 0x03:
15085                        goto op_semantics_131;
15086                        break;
15087                      case 0x04:
15088                        goto op_semantics_132;
15089                        break;
15090                      case 0x09:
15091                        goto op_semantics_133;
15092                        break;
15093                      case 0x0a:
15094                        goto op_semantics_134;
15095                        break;
15096                      case 0x0d:
15097                        goto op_semantics_135;
15098                        break;
15099                      default: UNSUPPORTED(); break;
15100                    }
15101                  break;
15102                case 0x8a:
15103                    GETBYTE ();
15104                    switch (op[3] & 0x0f)
15105                    {
15106                      case 0x00:
15107                        goto op_semantics_130;
15108                        break;
15109                      case 0x02:
15110                      case 0x03:
15111                        goto op_semantics_131;
15112                        break;
15113                      case 0x04:
15114                        goto op_semantics_132;
15115                        break;
15116                      case 0x09:
15117                        goto op_semantics_133;
15118                        break;
15119                      case 0x0a:
15120                        goto op_semantics_134;
15121                        break;
15122                      case 0x0d:
15123                        goto op_semantics_135;
15124                        break;
15125                      default: UNSUPPORTED(); break;
15126                    }
15127                  break;
15128                case 0x8b:
15129                    GETBYTE ();
15130                    switch (op[3] & 0x0f)
15131                    {
15132                      case 0x00:
15133                        goto op_semantics_130;
15134                        break;
15135                      case 0x02:
15136                      case 0x03:
15137                        goto op_semantics_131;
15138                        break;
15139                      case 0x04:
15140                        goto op_semantics_132;
15141                        break;
15142                      case 0x09:
15143                        goto op_semantics_133;
15144                        break;
15145                      case 0x0a:
15146                        goto op_semantics_134;
15147                        break;
15148                      case 0x0d:
15149                        goto op_semantics_135;
15150                        break;
15151                      default: UNSUPPORTED(); break;
15152                    }
15153                  break;
15154                case 0x8c:
15155                    GETBYTE ();
15156                    switch (op[3] & 0x0f)
15157                    {
15158                      case 0x00:
15159                        goto op_semantics_130;
15160                        break;
15161                      case 0x02:
15162                      case 0x03:
15163                        goto op_semantics_131;
15164                        break;
15165                      case 0x04:
15166                        goto op_semantics_132;
15167                        break;
15168                      case 0x09:
15169                        goto op_semantics_133;
15170                        break;
15171                      case 0x0a:
15172                        goto op_semantics_134;
15173                        break;
15174                      case 0x0d:
15175                        goto op_semantics_135;
15176                        break;
15177                      default: UNSUPPORTED(); break;
15178                    }
15179                  break;
15180                case 0x8d:
15181                    GETBYTE ();
15182                    switch (op[3] & 0x0f)
15183                    {
15184                      case 0x00:
15185                        goto op_semantics_130;
15186                        break;
15187                      case 0x02:
15188                      case 0x03:
15189                        goto op_semantics_131;
15190                        break;
15191                      case 0x04:
15192                        goto op_semantics_132;
15193                        break;
15194                      case 0x09:
15195                        goto op_semantics_133;
15196                        break;
15197                      case 0x0a:
15198                        goto op_semantics_134;
15199                        break;
15200                      case 0x0d:
15201                        goto op_semantics_135;
15202                        break;
15203                      default: UNSUPPORTED(); break;
15204                    }
15205                  break;
15206                case 0x8e:
15207                    GETBYTE ();
15208                    switch (op[3] & 0x0f)
15209                    {
15210                      case 0x00:
15211                        goto op_semantics_130;
15212                        break;
15213                      case 0x02:
15214                      case 0x03:
15215                        goto op_semantics_131;
15216                        break;
15217                      case 0x04:
15218                        goto op_semantics_132;
15219                        break;
15220                      case 0x09:
15221                        goto op_semantics_133;
15222                        break;
15223                      case 0x0a:
15224                        goto op_semantics_134;
15225                        break;
15226                      case 0x0d:
15227                        goto op_semantics_135;
15228                        break;
15229                      default: UNSUPPORTED(); break;
15230                    }
15231                  break;
15232                case 0x8f:
15233                    GETBYTE ();
15234                    switch (op[3] & 0x0f)
15235                    {
15236                      case 0x00:
15237                        goto op_semantics_130;
15238                        break;
15239                      case 0x02:
15240                      case 0x03:
15241                        goto op_semantics_131;
15242                        break;
15243                      case 0x04:
15244                        goto op_semantics_132;
15245                        break;
15246                      case 0x09:
15247                        goto op_semantics_133;
15248                        break;
15249                      case 0x0a:
15250                        goto op_semantics_134;
15251                        break;
15252                      case 0x0d:
15253                        goto op_semantics_135;
15254                        break;
15255                      default: UNSUPPORTED(); break;
15256                    }
15257                  break;
15258                default: UNSUPPORTED(); break;
15259              }
15260            break;
15261          case 0x78:
15262              GETBYTE ();
15263              switch (op[2] & 0xf0)
15264              {
15265                case 0x20:
15266                  goto op_semantics_113;
15267                  break;
15268                case 0x40:
15269                  goto op_semantics_114;
15270                  break;
15271                case 0x50:
15272                  goto op_semantics_115;
15273                  break;
15274                case 0x60:
15275                  goto op_semantics_116;
15276                  break;
15277                case 0x70:
15278                  goto op_semantics_117;
15279                  break;
15280                case 0x80:
15281                  goto op_semantics_118;
15282                  break;
15283                case 0x90:
15284                  goto op_semantics_119;
15285                  break;
15286                case 0xc0:
15287                  goto op_semantics_120;
15288                  break;
15289                case 0xd0:
15290                  goto op_semantics_121;
15291                  break;
15292                case 0xe0:
15293                  goto op_semantics_122;
15294                  break;
15295                case 0xf0:
15296                  goto op_semantics_123;
15297                  break;
15298                default: UNSUPPORTED(); break;
15299              }
15300            break;
15301          case 0x7b:
15302              GETBYTE ();
15303              switch (op[2] & 0xe0)
15304              {
15305                case 0x00:
15306                  goto op_semantics_124;
15307                  break;
15308                default: UNSUPPORTED(); break;
15309              }
15310            break;
15311          case 0x7c:
15312              GETBYTE ();
15313              switch (op[2] & 0xf0)
15314              {
15315                case 0x20:
15316                  goto op_semantics_113;
15317                  break;
15318                case 0x40:
15319                  goto op_semantics_114;
15320                  break;
15321                case 0x50:
15322                  goto op_semantics_115;
15323                  break;
15324                case 0x60:
15325                  goto op_semantics_116;
15326                  break;
15327                case 0x70:
15328                  goto op_semantics_117;
15329                  break;
15330                case 0x80:
15331                  goto op_semantics_118;
15332                  break;
15333                case 0x90:
15334                  goto op_semantics_119;
15335                  break;
15336                case 0xc0:
15337                  goto op_semantics_120;
15338                  break;
15339                case 0xd0:
15340                  goto op_semantics_121;
15341                  break;
15342                case 0xe0:
15343                  goto op_semantics_122;
15344                  break;
15345                case 0xf0:
15346                  goto op_semantics_123;
15347                  break;
15348                default: UNSUPPORTED(); break;
15349              }
15350            break;
15351          case 0x7f:
15352              GETBYTE ();
15353              switch (op[2] & 0xe0)
15354              {
15355                case 0x00:
15356                  goto op_semantics_124;
15357                  break;
15358                default: UNSUPPORTED(); break;
15359              }
15360            break;
15361          case 0x80:
15362              GETBYTE ();
15363              switch (op[2] & 0x00)
15364              {
15365                case 0x00:
15366                  op_semantics_136:
15367                    {
15368                      /** 1111 1101 100immmm rsrc rdst	shlr	#%2, %1, %0 */
15369#line 757 "rx-decode.opc"
15370                      int immmm AU = op[1] & 0x1f;
15371#line 757 "rx-decode.opc"
15372                      int rsrc AU = (op[2] >> 4) & 0x0f;
15373#line 757 "rx-decode.opc"
15374                      int rdst AU = op[2] & 0x0f;
15375                      if (trace)
15376                        {
15377                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15378                                 "/** 1111 1101 100immmm rsrc rdst	shlr	#%2, %1, %0 */",
15379                                 op[0], op[1], op[2]);
15380                          printf ("  immmm = 0x%x,", immmm);
15381                          printf ("  rsrc = 0x%x,", rsrc);
15382                          printf ("  rdst = 0x%x\n", rdst);
15383                        }
15384                      SYNTAX("shlr	#%2, %1, %0");
15385#line 757 "rx-decode.opc"
15386                      ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
15387
15388                    /*----------------------------------------------------------------------*/
15389                    /* ROTATE								*/
15390
15391                    }
15392                  break;
15393              }
15394            break;
15395          case 0x81:
15396              GETBYTE ();
15397              switch (op[2] & 0x00)
15398              {
15399                case 0x00:
15400                  goto op_semantics_136;
15401                  break;
15402              }
15403            break;
15404          case 0x82:
15405              GETBYTE ();
15406              switch (op[2] & 0x00)
15407              {
15408                case 0x00:
15409                  goto op_semantics_136;
15410                  break;
15411              }
15412            break;
15413          case 0x83:
15414              GETBYTE ();
15415              switch (op[2] & 0x00)
15416              {
15417                case 0x00:
15418                  goto op_semantics_136;
15419                  break;
15420              }
15421            break;
15422          case 0x84:
15423              GETBYTE ();
15424              switch (op[2] & 0x00)
15425              {
15426                case 0x00:
15427                  goto op_semantics_136;
15428                  break;
15429              }
15430            break;
15431          case 0x85:
15432              GETBYTE ();
15433              switch (op[2] & 0x00)
15434              {
15435                case 0x00:
15436                  goto op_semantics_136;
15437                  break;
15438              }
15439            break;
15440          case 0x86:
15441              GETBYTE ();
15442              switch (op[2] & 0x00)
15443              {
15444                case 0x00:
15445                  goto op_semantics_136;
15446                  break;
15447              }
15448            break;
15449          case 0x87:
15450              GETBYTE ();
15451              switch (op[2] & 0x00)
15452              {
15453                case 0x00:
15454                  goto op_semantics_136;
15455                  break;
15456              }
15457            break;
15458          case 0x88:
15459              GETBYTE ();
15460              switch (op[2] & 0x00)
15461              {
15462                case 0x00:
15463                  goto op_semantics_136;
15464                  break;
15465              }
15466            break;
15467          case 0x89:
15468              GETBYTE ();
15469              switch (op[2] & 0x00)
15470              {
15471                case 0x00:
15472                  goto op_semantics_136;
15473                  break;
15474              }
15475            break;
15476          case 0x8a:
15477              GETBYTE ();
15478              switch (op[2] & 0x00)
15479              {
15480                case 0x00:
15481                  goto op_semantics_136;
15482                  break;
15483              }
15484            break;
15485          case 0x8b:
15486              GETBYTE ();
15487              switch (op[2] & 0x00)
15488              {
15489                case 0x00:
15490                  goto op_semantics_136;
15491                  break;
15492              }
15493            break;
15494          case 0x8c:
15495              GETBYTE ();
15496              switch (op[2] & 0x00)
15497              {
15498                case 0x00:
15499                  goto op_semantics_136;
15500                  break;
15501              }
15502            break;
15503          case 0x8d:
15504              GETBYTE ();
15505              switch (op[2] & 0x00)
15506              {
15507                case 0x00:
15508                  goto op_semantics_136;
15509                  break;
15510              }
15511            break;
15512          case 0x8e:
15513              GETBYTE ();
15514              switch (op[2] & 0x00)
15515              {
15516                case 0x00:
15517                  goto op_semantics_136;
15518                  break;
15519              }
15520            break;
15521          case 0x8f:
15522              GETBYTE ();
15523              switch (op[2] & 0x00)
15524              {
15525                case 0x00:
15526                  goto op_semantics_136;
15527                  break;
15528              }
15529            break;
15530          case 0x90:
15531              GETBYTE ();
15532              switch (op[2] & 0x00)
15533              {
15534                case 0x00:
15535                  goto op_semantics_136;
15536                  break;
15537              }
15538            break;
15539          case 0x91:
15540              GETBYTE ();
15541              switch (op[2] & 0x00)
15542              {
15543                case 0x00:
15544                  goto op_semantics_136;
15545                  break;
15546              }
15547            break;
15548          case 0x92:
15549              GETBYTE ();
15550              switch (op[2] & 0x00)
15551              {
15552                case 0x00:
15553                  goto op_semantics_136;
15554                  break;
15555              }
15556            break;
15557          case 0x93:
15558              GETBYTE ();
15559              switch (op[2] & 0x00)
15560              {
15561                case 0x00:
15562                  goto op_semantics_136;
15563                  break;
15564              }
15565            break;
15566          case 0x94:
15567              GETBYTE ();
15568              switch (op[2] & 0x00)
15569              {
15570                case 0x00:
15571                  goto op_semantics_136;
15572                  break;
15573              }
15574            break;
15575          case 0x95:
15576              GETBYTE ();
15577              switch (op[2] & 0x00)
15578              {
15579                case 0x00:
15580                  goto op_semantics_136;
15581                  break;
15582              }
15583            break;
15584          case 0x96:
15585              GETBYTE ();
15586              switch (op[2] & 0x00)
15587              {
15588                case 0x00:
15589                  goto op_semantics_136;
15590                  break;
15591              }
15592            break;
15593          case 0x97:
15594              GETBYTE ();
15595              switch (op[2] & 0x00)
15596              {
15597                case 0x00:
15598                  goto op_semantics_136;
15599                  break;
15600              }
15601            break;
15602          case 0x98:
15603              GETBYTE ();
15604              switch (op[2] & 0x00)
15605              {
15606                case 0x00:
15607                  goto op_semantics_136;
15608                  break;
15609              }
15610            break;
15611          case 0x99:
15612              GETBYTE ();
15613              switch (op[2] & 0x00)
15614              {
15615                case 0x00:
15616                  goto op_semantics_136;
15617                  break;
15618              }
15619            break;
15620          case 0x9a:
15621              GETBYTE ();
15622              switch (op[2] & 0x00)
15623              {
15624                case 0x00:
15625                  goto op_semantics_136;
15626                  break;
15627              }
15628            break;
15629          case 0x9b:
15630              GETBYTE ();
15631              switch (op[2] & 0x00)
15632              {
15633                case 0x00:
15634                  goto op_semantics_136;
15635                  break;
15636              }
15637            break;
15638          case 0x9c:
15639              GETBYTE ();
15640              switch (op[2] & 0x00)
15641              {
15642                case 0x00:
15643                  goto op_semantics_136;
15644                  break;
15645              }
15646            break;
15647          case 0x9d:
15648              GETBYTE ();
15649              switch (op[2] & 0x00)
15650              {
15651                case 0x00:
15652                  goto op_semantics_136;
15653                  break;
15654              }
15655            break;
15656          case 0x9e:
15657              GETBYTE ();
15658              switch (op[2] & 0x00)
15659              {
15660                case 0x00:
15661                  goto op_semantics_136;
15662                  break;
15663              }
15664            break;
15665          case 0x9f:
15666              GETBYTE ();
15667              switch (op[2] & 0x00)
15668              {
15669                case 0x00:
15670                  goto op_semantics_136;
15671                  break;
15672              }
15673            break;
15674          case 0xa0:
15675              GETBYTE ();
15676              switch (op[2] & 0x00)
15677              {
15678                case 0x00:
15679                  op_semantics_137:
15680                    {
15681                      /** 1111 1101 101immmm rsrc rdst	shar	#%2, %1, %0 */
15682#line 747 "rx-decode.opc"
15683                      int immmm AU = op[1] & 0x1f;
15684#line 747 "rx-decode.opc"
15685                      int rsrc AU = (op[2] >> 4) & 0x0f;
15686#line 747 "rx-decode.opc"
15687                      int rdst AU = op[2] & 0x0f;
15688                      if (trace)
15689                        {
15690                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15691                                 "/** 1111 1101 101immmm rsrc rdst	shar	#%2, %1, %0 */",
15692                                 op[0], op[1], op[2]);
15693                          printf ("  immmm = 0x%x,", immmm);
15694                          printf ("  rsrc = 0x%x,", rsrc);
15695                          printf ("  rdst = 0x%x\n", rdst);
15696                        }
15697                      SYNTAX("shar	#%2, %1, %0");
15698#line 747 "rx-decode.opc"
15699                      ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
15700
15701
15702                    }
15703                  break;
15704              }
15705            break;
15706          case 0xa1:
15707              GETBYTE ();
15708              switch (op[2] & 0x00)
15709              {
15710                case 0x00:
15711                  goto op_semantics_137;
15712                  break;
15713              }
15714            break;
15715          case 0xa2:
15716              GETBYTE ();
15717              switch (op[2] & 0x00)
15718              {
15719                case 0x00:
15720                  goto op_semantics_137;
15721                  break;
15722              }
15723            break;
15724          case 0xa3:
15725              GETBYTE ();
15726              switch (op[2] & 0x00)
15727              {
15728                case 0x00:
15729                  goto op_semantics_137;
15730                  break;
15731              }
15732            break;
15733          case 0xa4:
15734              GETBYTE ();
15735              switch (op[2] & 0x00)
15736              {
15737                case 0x00:
15738                  goto op_semantics_137;
15739                  break;
15740              }
15741            break;
15742          case 0xa5:
15743              GETBYTE ();
15744              switch (op[2] & 0x00)
15745              {
15746                case 0x00:
15747                  goto op_semantics_137;
15748                  break;
15749              }
15750            break;
15751          case 0xa6:
15752              GETBYTE ();
15753              switch (op[2] & 0x00)
15754              {
15755                case 0x00:
15756                  goto op_semantics_137;
15757                  break;
15758              }
15759            break;
15760          case 0xa7:
15761              GETBYTE ();
15762              switch (op[2] & 0x00)
15763              {
15764                case 0x00:
15765                  goto op_semantics_137;
15766                  break;
15767              }
15768            break;
15769          case 0xa8:
15770              GETBYTE ();
15771              switch (op[2] & 0x00)
15772              {
15773                case 0x00:
15774                  goto op_semantics_137;
15775                  break;
15776              }
15777            break;
15778          case 0xa9:
15779              GETBYTE ();
15780              switch (op[2] & 0x00)
15781              {
15782                case 0x00:
15783                  goto op_semantics_137;
15784                  break;
15785              }
15786            break;
15787          case 0xaa:
15788              GETBYTE ();
15789              switch (op[2] & 0x00)
15790              {
15791                case 0x00:
15792                  goto op_semantics_137;
15793                  break;
15794              }
15795            break;
15796          case 0xab:
15797              GETBYTE ();
15798              switch (op[2] & 0x00)
15799              {
15800                case 0x00:
15801                  goto op_semantics_137;
15802                  break;
15803              }
15804            break;
15805          case 0xac:
15806              GETBYTE ();
15807              switch (op[2] & 0x00)
15808              {
15809                case 0x00:
15810                  goto op_semantics_137;
15811                  break;
15812              }
15813            break;
15814          case 0xad:
15815              GETBYTE ();
15816              switch (op[2] & 0x00)
15817              {
15818                case 0x00:
15819                  goto op_semantics_137;
15820                  break;
15821              }
15822            break;
15823          case 0xae:
15824              GETBYTE ();
15825              switch (op[2] & 0x00)
15826              {
15827                case 0x00:
15828                  goto op_semantics_137;
15829                  break;
15830              }
15831            break;
15832          case 0xaf:
15833              GETBYTE ();
15834              switch (op[2] & 0x00)
15835              {
15836                case 0x00:
15837                  goto op_semantics_137;
15838                  break;
15839              }
15840            break;
15841          case 0xb0:
15842              GETBYTE ();
15843              switch (op[2] & 0x00)
15844              {
15845                case 0x00:
15846                  goto op_semantics_137;
15847                  break;
15848              }
15849            break;
15850          case 0xb1:
15851              GETBYTE ();
15852              switch (op[2] & 0x00)
15853              {
15854                case 0x00:
15855                  goto op_semantics_137;
15856                  break;
15857              }
15858            break;
15859          case 0xb2:
15860              GETBYTE ();
15861              switch (op[2] & 0x00)
15862              {
15863                case 0x00:
15864                  goto op_semantics_137;
15865                  break;
15866              }
15867            break;
15868          case 0xb3:
15869              GETBYTE ();
15870              switch (op[2] & 0x00)
15871              {
15872                case 0x00:
15873                  goto op_semantics_137;
15874                  break;
15875              }
15876            break;
15877          case 0xb4:
15878              GETBYTE ();
15879              switch (op[2] & 0x00)
15880              {
15881                case 0x00:
15882                  goto op_semantics_137;
15883                  break;
15884              }
15885            break;
15886          case 0xb5:
15887              GETBYTE ();
15888              switch (op[2] & 0x00)
15889              {
15890                case 0x00:
15891                  goto op_semantics_137;
15892                  break;
15893              }
15894            break;
15895          case 0xb6:
15896              GETBYTE ();
15897              switch (op[2] & 0x00)
15898              {
15899                case 0x00:
15900                  goto op_semantics_137;
15901                  break;
15902              }
15903            break;
15904          case 0xb7:
15905              GETBYTE ();
15906              switch (op[2] & 0x00)
15907              {
15908                case 0x00:
15909                  goto op_semantics_137;
15910                  break;
15911              }
15912            break;
15913          case 0xb8:
15914              GETBYTE ();
15915              switch (op[2] & 0x00)
15916              {
15917                case 0x00:
15918                  goto op_semantics_137;
15919                  break;
15920              }
15921            break;
15922          case 0xb9:
15923              GETBYTE ();
15924              switch (op[2] & 0x00)
15925              {
15926                case 0x00:
15927                  goto op_semantics_137;
15928                  break;
15929              }
15930            break;
15931          case 0xba:
15932              GETBYTE ();
15933              switch (op[2] & 0x00)
15934              {
15935                case 0x00:
15936                  goto op_semantics_137;
15937                  break;
15938              }
15939            break;
15940          case 0xbb:
15941              GETBYTE ();
15942              switch (op[2] & 0x00)
15943              {
15944                case 0x00:
15945                  goto op_semantics_137;
15946                  break;
15947              }
15948            break;
15949          case 0xbc:
15950              GETBYTE ();
15951              switch (op[2] & 0x00)
15952              {
15953                case 0x00:
15954                  goto op_semantics_137;
15955                  break;
15956              }
15957            break;
15958          case 0xbd:
15959              GETBYTE ();
15960              switch (op[2] & 0x00)
15961              {
15962                case 0x00:
15963                  goto op_semantics_137;
15964                  break;
15965              }
15966            break;
15967          case 0xbe:
15968              GETBYTE ();
15969              switch (op[2] & 0x00)
15970              {
15971                case 0x00:
15972                  goto op_semantics_137;
15973                  break;
15974              }
15975            break;
15976          case 0xbf:
15977              GETBYTE ();
15978              switch (op[2] & 0x00)
15979              {
15980                case 0x00:
15981                  goto op_semantics_137;
15982                  break;
15983              }
15984            break;
15985          case 0xc0:
15986              GETBYTE ();
15987              switch (op[2] & 0x00)
15988              {
15989                case 0x00:
15990                  op_semantics_138:
15991                    {
15992                      /** 1111 1101 110immmm rsrc rdst	shll	#%2, %1, %0 */
15993#line 737 "rx-decode.opc"
15994                      int immmm AU = op[1] & 0x1f;
15995#line 737 "rx-decode.opc"
15996                      int rsrc AU = (op[2] >> 4) & 0x0f;
15997#line 737 "rx-decode.opc"
15998                      int rdst AU = op[2] & 0x0f;
15999                      if (trace)
16000                        {
16001                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16002                                 "/** 1111 1101 110immmm rsrc rdst	shll	#%2, %1, %0 */",
16003                                 op[0], op[1], op[2]);
16004                          printf ("  immmm = 0x%x,", immmm);
16005                          printf ("  rsrc = 0x%x,", rsrc);
16006                          printf ("  rdst = 0x%x\n", rdst);
16007                        }
16008                      SYNTAX("shll	#%2, %1, %0");
16009#line 737 "rx-decode.opc"
16010                      ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
16011
16012
16013                    }
16014                  break;
16015              }
16016            break;
16017          case 0xc1:
16018              GETBYTE ();
16019              switch (op[2] & 0x00)
16020              {
16021                case 0x00:
16022                  goto op_semantics_138;
16023                  break;
16024              }
16025            break;
16026          case 0xc2:
16027              GETBYTE ();
16028              switch (op[2] & 0x00)
16029              {
16030                case 0x00:
16031                  goto op_semantics_138;
16032                  break;
16033              }
16034            break;
16035          case 0xc3:
16036              GETBYTE ();
16037              switch (op[2] & 0x00)
16038              {
16039                case 0x00:
16040                  goto op_semantics_138;
16041                  break;
16042              }
16043            break;
16044          case 0xc4:
16045              GETBYTE ();
16046              switch (op[2] & 0x00)
16047              {
16048                case 0x00:
16049                  goto op_semantics_138;
16050                  break;
16051              }
16052            break;
16053          case 0xc5:
16054              GETBYTE ();
16055              switch (op[2] & 0x00)
16056              {
16057                case 0x00:
16058                  goto op_semantics_138;
16059                  break;
16060              }
16061            break;
16062          case 0xc6:
16063              GETBYTE ();
16064              switch (op[2] & 0x00)
16065              {
16066                case 0x00:
16067                  goto op_semantics_138;
16068                  break;
16069              }
16070            break;
16071          case 0xc7:
16072              GETBYTE ();
16073              switch (op[2] & 0x00)
16074              {
16075                case 0x00:
16076                  goto op_semantics_138;
16077                  break;
16078              }
16079            break;
16080          case 0xc8:
16081              GETBYTE ();
16082              switch (op[2] & 0x00)
16083              {
16084                case 0x00:
16085                  goto op_semantics_138;
16086                  break;
16087              }
16088            break;
16089          case 0xc9:
16090              GETBYTE ();
16091              switch (op[2] & 0x00)
16092              {
16093                case 0x00:
16094                  goto op_semantics_138;
16095                  break;
16096              }
16097            break;
16098          case 0xca:
16099              GETBYTE ();
16100              switch (op[2] & 0x00)
16101              {
16102                case 0x00:
16103                  goto op_semantics_138;
16104                  break;
16105              }
16106            break;
16107          case 0xcb:
16108              GETBYTE ();
16109              switch (op[2] & 0x00)
16110              {
16111                case 0x00:
16112                  goto op_semantics_138;
16113                  break;
16114              }
16115            break;
16116          case 0xcc:
16117              GETBYTE ();
16118              switch (op[2] & 0x00)
16119              {
16120                case 0x00:
16121                  goto op_semantics_138;
16122                  break;
16123              }
16124            break;
16125          case 0xcd:
16126              GETBYTE ();
16127              switch (op[2] & 0x00)
16128              {
16129                case 0x00:
16130                  goto op_semantics_138;
16131                  break;
16132              }
16133            break;
16134          case 0xce:
16135              GETBYTE ();
16136              switch (op[2] & 0x00)
16137              {
16138                case 0x00:
16139                  goto op_semantics_138;
16140                  break;
16141              }
16142            break;
16143          case 0xcf:
16144              GETBYTE ();
16145              switch (op[2] & 0x00)
16146              {
16147                case 0x00:
16148                  goto op_semantics_138;
16149                  break;
16150              }
16151            break;
16152          case 0xd0:
16153              GETBYTE ();
16154              switch (op[2] & 0x00)
16155              {
16156                case 0x00:
16157                  goto op_semantics_138;
16158                  break;
16159              }
16160            break;
16161          case 0xd1:
16162              GETBYTE ();
16163              switch (op[2] & 0x00)
16164              {
16165                case 0x00:
16166                  goto op_semantics_138;
16167                  break;
16168              }
16169            break;
16170          case 0xd2:
16171              GETBYTE ();
16172              switch (op[2] & 0x00)
16173              {
16174                case 0x00:
16175                  goto op_semantics_138;
16176                  break;
16177              }
16178            break;
16179          case 0xd3:
16180              GETBYTE ();
16181              switch (op[2] & 0x00)
16182              {
16183                case 0x00:
16184                  goto op_semantics_138;
16185                  break;
16186              }
16187            break;
16188          case 0xd4:
16189              GETBYTE ();
16190              switch (op[2] & 0x00)
16191              {
16192                case 0x00:
16193                  goto op_semantics_138;
16194                  break;
16195              }
16196            break;
16197          case 0xd5:
16198              GETBYTE ();
16199              switch (op[2] & 0x00)
16200              {
16201                case 0x00:
16202                  goto op_semantics_138;
16203                  break;
16204              }
16205            break;
16206          case 0xd6:
16207              GETBYTE ();
16208              switch (op[2] & 0x00)
16209              {
16210                case 0x00:
16211                  goto op_semantics_138;
16212                  break;
16213              }
16214            break;
16215          case 0xd7:
16216              GETBYTE ();
16217              switch (op[2] & 0x00)
16218              {
16219                case 0x00:
16220                  goto op_semantics_138;
16221                  break;
16222              }
16223            break;
16224          case 0xd8:
16225              GETBYTE ();
16226              switch (op[2] & 0x00)
16227              {
16228                case 0x00:
16229                  goto op_semantics_138;
16230                  break;
16231              }
16232            break;
16233          case 0xd9:
16234              GETBYTE ();
16235              switch (op[2] & 0x00)
16236              {
16237                case 0x00:
16238                  goto op_semantics_138;
16239                  break;
16240              }
16241            break;
16242          case 0xda:
16243              GETBYTE ();
16244              switch (op[2] & 0x00)
16245              {
16246                case 0x00:
16247                  goto op_semantics_138;
16248                  break;
16249              }
16250            break;
16251          case 0xdb:
16252              GETBYTE ();
16253              switch (op[2] & 0x00)
16254              {
16255                case 0x00:
16256                  goto op_semantics_138;
16257                  break;
16258              }
16259            break;
16260          case 0xdc:
16261              GETBYTE ();
16262              switch (op[2] & 0x00)
16263              {
16264                case 0x00:
16265                  goto op_semantics_138;
16266                  break;
16267              }
16268            break;
16269          case 0xdd:
16270              GETBYTE ();
16271              switch (op[2] & 0x00)
16272              {
16273                case 0x00:
16274                  goto op_semantics_138;
16275                  break;
16276              }
16277            break;
16278          case 0xde:
16279              GETBYTE ();
16280              switch (op[2] & 0x00)
16281              {
16282                case 0x00:
16283                  goto op_semantics_138;
16284                  break;
16285              }
16286            break;
16287          case 0xdf:
16288              GETBYTE ();
16289              switch (op[2] & 0x00)
16290              {
16291                case 0x00:
16292                  goto op_semantics_138;
16293                  break;
16294              }
16295            break;
16296          case 0xe0:
16297              GETBYTE ();
16298              switch (op[2] & 0xf0)
16299              {
16300                case 0x00:
16301                case 0x10:
16302                case 0x20:
16303                case 0x30:
16304                case 0x40:
16305                case 0x50:
16306                case 0x60:
16307                case 0x70:
16308                case 0x80:
16309                case 0x90:
16310                case 0xa0:
16311                case 0xb0:
16312                case 0xc0:
16313                case 0xd0:
16314                case 0xe0:
16315                  op_semantics_139:
16316                    {
16317                      /** 1111 1101 111 bittt cond rdst	bm%2	#%1, %0%S0 */
16318#line 1011 "rx-decode.opc"
16319                      int bittt AU = op[1] & 0x1f;
16320#line 1011 "rx-decode.opc"
16321                      int cond AU = (op[2] >> 4) & 0x0f;
16322#line 1011 "rx-decode.opc"
16323                      int rdst AU = op[2] & 0x0f;
16324                      if (trace)
16325                        {
16326                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16327                                 "/** 1111 1101 111 bittt cond rdst	bm%2	#%1, %0%S0 */",
16328                                 op[0], op[1], op[2]);
16329                          printf ("  bittt = 0x%x,", bittt);
16330                          printf ("  cond = 0x%x,", cond);
16331                          printf ("  rdst = 0x%x\n", rdst);
16332                        }
16333                      SYNTAX("bm%2	#%1, %0%S0");
16334#line 1011 "rx-decode.opc"
16335                      ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16336
16337                    /*----------------------------------------------------------------------*/
16338                    /* CONTROL REGISTERS							*/
16339
16340                    }
16341                  break;
16342                case 0xf0:
16343                  op_semantics_140:
16344                    {
16345                      /** 1111 1101 111bittt 1111 rdst	bnot	#%1, %0 */
16346#line 1004 "rx-decode.opc"
16347                      int bittt AU = op[1] & 0x1f;
16348#line 1004 "rx-decode.opc"
16349                      int rdst AU = op[2] & 0x0f;
16350                      if (trace)
16351                        {
16352                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16353                                 "/** 1111 1101 111bittt 1111 rdst	bnot	#%1, %0 */",
16354                                 op[0], op[1], op[2]);
16355                          printf ("  bittt = 0x%x,", bittt);
16356                          printf ("  rdst = 0x%x\n", rdst);
16357                        }
16358                      SYNTAX("bnot	#%1, %0");
16359#line 1004 "rx-decode.opc"
16360                      ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16361
16362
16363                    }
16364                  break;
16365              }
16366            break;
16367          case 0xe1:
16368              GETBYTE ();
16369              switch (op[2] & 0xf0)
16370              {
16371                case 0x00:
16372                case 0x10:
16373                case 0x20:
16374                case 0x30:
16375                case 0x40:
16376                case 0x50:
16377                case 0x60:
16378                case 0x70:
16379                case 0x80:
16380                case 0x90:
16381                case 0xa0:
16382                case 0xb0:
16383                case 0xc0:
16384                case 0xd0:
16385                case 0xe0:
16386                  goto op_semantics_139;
16387                  break;
16388                case 0xf0:
16389                  goto op_semantics_140;
16390                  break;
16391              }
16392            break;
16393          case 0xe2:
16394              GETBYTE ();
16395              switch (op[2] & 0xf0)
16396              {
16397                case 0x00:
16398                case 0x10:
16399                case 0x20:
16400                case 0x30:
16401                case 0x40:
16402                case 0x50:
16403                case 0x60:
16404                case 0x70:
16405                case 0x80:
16406                case 0x90:
16407                case 0xa0:
16408                case 0xb0:
16409                case 0xc0:
16410                case 0xd0:
16411                case 0xe0:
16412                  goto op_semantics_139;
16413                  break;
16414                case 0xf0:
16415                  goto op_semantics_140;
16416                  break;
16417              }
16418            break;
16419          case 0xe3:
16420              GETBYTE ();
16421              switch (op[2] & 0xf0)
16422              {
16423                case 0x00:
16424                case 0x10:
16425                case 0x20:
16426                case 0x30:
16427                case 0x40:
16428                case 0x50:
16429                case 0x60:
16430                case 0x70:
16431                case 0x80:
16432                case 0x90:
16433                case 0xa0:
16434                case 0xb0:
16435                case 0xc0:
16436                case 0xd0:
16437                case 0xe0:
16438                  goto op_semantics_139;
16439                  break;
16440                case 0xf0:
16441                  goto op_semantics_140;
16442                  break;
16443              }
16444            break;
16445          case 0xe4:
16446              GETBYTE ();
16447              switch (op[2] & 0xf0)
16448              {
16449                case 0x00:
16450                case 0x10:
16451                case 0x20:
16452                case 0x30:
16453                case 0x40:
16454                case 0x50:
16455                case 0x60:
16456                case 0x70:
16457                case 0x80:
16458                case 0x90:
16459                case 0xa0:
16460                case 0xb0:
16461                case 0xc0:
16462                case 0xd0:
16463                case 0xe0:
16464                  goto op_semantics_139;
16465                  break;
16466                case 0xf0:
16467                  goto op_semantics_140;
16468                  break;
16469              }
16470            break;
16471          case 0xe5:
16472              GETBYTE ();
16473              switch (op[2] & 0xf0)
16474              {
16475                case 0x00:
16476                case 0x10:
16477                case 0x20:
16478                case 0x30:
16479                case 0x40:
16480                case 0x50:
16481                case 0x60:
16482                case 0x70:
16483                case 0x80:
16484                case 0x90:
16485                case 0xa0:
16486                case 0xb0:
16487                case 0xc0:
16488                case 0xd0:
16489                case 0xe0:
16490                  goto op_semantics_139;
16491                  break;
16492                case 0xf0:
16493                  goto op_semantics_140;
16494                  break;
16495              }
16496            break;
16497          case 0xe6:
16498              GETBYTE ();
16499              switch (op[2] & 0xf0)
16500              {
16501                case 0x00:
16502                case 0x10:
16503                case 0x20:
16504                case 0x30:
16505                case 0x40:
16506                case 0x50:
16507                case 0x60:
16508                case 0x70:
16509                case 0x80:
16510                case 0x90:
16511                case 0xa0:
16512                case 0xb0:
16513                case 0xc0:
16514                case 0xd0:
16515                case 0xe0:
16516                  goto op_semantics_139;
16517                  break;
16518                case 0xf0:
16519                  goto op_semantics_140;
16520                  break;
16521              }
16522            break;
16523          case 0xe7:
16524              GETBYTE ();
16525              switch (op[2] & 0xf0)
16526              {
16527                case 0x00:
16528                case 0x10:
16529                case 0x20:
16530                case 0x30:
16531                case 0x40:
16532                case 0x50:
16533                case 0x60:
16534                case 0x70:
16535                case 0x80:
16536                case 0x90:
16537                case 0xa0:
16538                case 0xb0:
16539                case 0xc0:
16540                case 0xd0:
16541                case 0xe0:
16542                  goto op_semantics_139;
16543                  break;
16544                case 0xf0:
16545                  goto op_semantics_140;
16546                  break;
16547              }
16548            break;
16549          case 0xe8:
16550              GETBYTE ();
16551              switch (op[2] & 0xf0)
16552              {
16553                case 0x00:
16554                case 0x10:
16555                case 0x20:
16556                case 0x30:
16557                case 0x40:
16558                case 0x50:
16559                case 0x60:
16560                case 0x70:
16561                case 0x80:
16562                case 0x90:
16563                case 0xa0:
16564                case 0xb0:
16565                case 0xc0:
16566                case 0xd0:
16567                case 0xe0:
16568                  goto op_semantics_139;
16569                  break;
16570                case 0xf0:
16571                  goto op_semantics_140;
16572                  break;
16573              }
16574            break;
16575          case 0xe9:
16576              GETBYTE ();
16577              switch (op[2] & 0xf0)
16578              {
16579                case 0x00:
16580                case 0x10:
16581                case 0x20:
16582                case 0x30:
16583                case 0x40:
16584                case 0x50:
16585                case 0x60:
16586                case 0x70:
16587                case 0x80:
16588                case 0x90:
16589                case 0xa0:
16590                case 0xb0:
16591                case 0xc0:
16592                case 0xd0:
16593                case 0xe0:
16594                  goto op_semantics_139;
16595                  break;
16596                case 0xf0:
16597                  goto op_semantics_140;
16598                  break;
16599              }
16600            break;
16601          case 0xea:
16602              GETBYTE ();
16603              switch (op[2] & 0xf0)
16604              {
16605                case 0x00:
16606                case 0x10:
16607                case 0x20:
16608                case 0x30:
16609                case 0x40:
16610                case 0x50:
16611                case 0x60:
16612                case 0x70:
16613                case 0x80:
16614                case 0x90:
16615                case 0xa0:
16616                case 0xb0:
16617                case 0xc0:
16618                case 0xd0:
16619                case 0xe0:
16620                  goto op_semantics_139;
16621                  break;
16622                case 0xf0:
16623                  goto op_semantics_140;
16624                  break;
16625              }
16626            break;
16627          case 0xeb:
16628              GETBYTE ();
16629              switch (op[2] & 0xf0)
16630              {
16631                case 0x00:
16632                case 0x10:
16633                case 0x20:
16634                case 0x30:
16635                case 0x40:
16636                case 0x50:
16637                case 0x60:
16638                case 0x70:
16639                case 0x80:
16640                case 0x90:
16641                case 0xa0:
16642                case 0xb0:
16643                case 0xc0:
16644                case 0xd0:
16645                case 0xe0:
16646                  goto op_semantics_139;
16647                  break;
16648                case 0xf0:
16649                  goto op_semantics_140;
16650                  break;
16651              }
16652            break;
16653          case 0xec:
16654              GETBYTE ();
16655              switch (op[2] & 0xf0)
16656              {
16657                case 0x00:
16658                case 0x10:
16659                case 0x20:
16660                case 0x30:
16661                case 0x40:
16662                case 0x50:
16663                case 0x60:
16664                case 0x70:
16665                case 0x80:
16666                case 0x90:
16667                case 0xa0:
16668                case 0xb0:
16669                case 0xc0:
16670                case 0xd0:
16671                case 0xe0:
16672                  goto op_semantics_139;
16673                  break;
16674                case 0xf0:
16675                  goto op_semantics_140;
16676                  break;
16677              }
16678            break;
16679          case 0xed:
16680              GETBYTE ();
16681              switch (op[2] & 0xf0)
16682              {
16683                case 0x00:
16684                case 0x10:
16685                case 0x20:
16686                case 0x30:
16687                case 0x40:
16688                case 0x50:
16689                case 0x60:
16690                case 0x70:
16691                case 0x80:
16692                case 0x90:
16693                case 0xa0:
16694                case 0xb0:
16695                case 0xc0:
16696                case 0xd0:
16697                case 0xe0:
16698                  goto op_semantics_139;
16699                  break;
16700                case 0xf0:
16701                  goto op_semantics_140;
16702                  break;
16703              }
16704            break;
16705          case 0xee:
16706              GETBYTE ();
16707              switch (op[2] & 0xf0)
16708              {
16709                case 0x00:
16710                case 0x10:
16711                case 0x20:
16712                case 0x30:
16713                case 0x40:
16714                case 0x50:
16715                case 0x60:
16716                case 0x70:
16717                case 0x80:
16718                case 0x90:
16719                case 0xa0:
16720                case 0xb0:
16721                case 0xc0:
16722                case 0xd0:
16723                case 0xe0:
16724                  goto op_semantics_139;
16725                  break;
16726                case 0xf0:
16727                  goto op_semantics_140;
16728                  break;
16729              }
16730            break;
16731          case 0xef:
16732              GETBYTE ();
16733              switch (op[2] & 0xf0)
16734              {
16735                case 0x00:
16736                case 0x10:
16737                case 0x20:
16738                case 0x30:
16739                case 0x40:
16740                case 0x50:
16741                case 0x60:
16742                case 0x70:
16743                case 0x80:
16744                case 0x90:
16745                case 0xa0:
16746                case 0xb0:
16747                case 0xc0:
16748                case 0xd0:
16749                case 0xe0:
16750                  goto op_semantics_139;
16751                  break;
16752                case 0xf0:
16753                  goto op_semantics_140;
16754                  break;
16755              }
16756            break;
16757          case 0xf0:
16758              GETBYTE ();
16759              switch (op[2] & 0xf0)
16760              {
16761                case 0x00:
16762                case 0x10:
16763                case 0x20:
16764                case 0x30:
16765                case 0x40:
16766                case 0x50:
16767                case 0x60:
16768                case 0x70:
16769                case 0x80:
16770                case 0x90:
16771                case 0xa0:
16772                case 0xb0:
16773                case 0xc0:
16774                case 0xd0:
16775                case 0xe0:
16776                  goto op_semantics_139;
16777                  break;
16778                case 0xf0:
16779                  goto op_semantics_140;
16780                  break;
16781              }
16782            break;
16783          case 0xf1:
16784              GETBYTE ();
16785              switch (op[2] & 0xf0)
16786              {
16787                case 0x00:
16788                case 0x10:
16789                case 0x20:
16790                case 0x30:
16791                case 0x40:
16792                case 0x50:
16793                case 0x60:
16794                case 0x70:
16795                case 0x80:
16796                case 0x90:
16797                case 0xa0:
16798                case 0xb0:
16799                case 0xc0:
16800                case 0xd0:
16801                case 0xe0:
16802                  goto op_semantics_139;
16803                  break;
16804                case 0xf0:
16805                  goto op_semantics_140;
16806                  break;
16807              }
16808            break;
16809          case 0xf2:
16810              GETBYTE ();
16811              switch (op[2] & 0xf0)
16812              {
16813                case 0x00:
16814                case 0x10:
16815                case 0x20:
16816                case 0x30:
16817                case 0x40:
16818                case 0x50:
16819                case 0x60:
16820                case 0x70:
16821                case 0x80:
16822                case 0x90:
16823                case 0xa0:
16824                case 0xb0:
16825                case 0xc0:
16826                case 0xd0:
16827                case 0xe0:
16828                  goto op_semantics_139;
16829                  break;
16830                case 0xf0:
16831                  goto op_semantics_140;
16832                  break;
16833              }
16834            break;
16835          case 0xf3:
16836              GETBYTE ();
16837              switch (op[2] & 0xf0)
16838              {
16839                case 0x00:
16840                case 0x10:
16841                case 0x20:
16842                case 0x30:
16843                case 0x40:
16844                case 0x50:
16845                case 0x60:
16846                case 0x70:
16847                case 0x80:
16848                case 0x90:
16849                case 0xa0:
16850                case 0xb0:
16851                case 0xc0:
16852                case 0xd0:
16853                case 0xe0:
16854                  goto op_semantics_139;
16855                  break;
16856                case 0xf0:
16857                  goto op_semantics_140;
16858                  break;
16859              }
16860            break;
16861          case 0xf4:
16862              GETBYTE ();
16863              switch (op[2] & 0xf0)
16864              {
16865                case 0x00:
16866                case 0x10:
16867                case 0x20:
16868                case 0x30:
16869                case 0x40:
16870                case 0x50:
16871                case 0x60:
16872                case 0x70:
16873                case 0x80:
16874                case 0x90:
16875                case 0xa0:
16876                case 0xb0:
16877                case 0xc0:
16878                case 0xd0:
16879                case 0xe0:
16880                  goto op_semantics_139;
16881                  break;
16882                case 0xf0:
16883                  goto op_semantics_140;
16884                  break;
16885              }
16886            break;
16887          case 0xf5:
16888              GETBYTE ();
16889              switch (op[2] & 0xf0)
16890              {
16891                case 0x00:
16892                case 0x10:
16893                case 0x20:
16894                case 0x30:
16895                case 0x40:
16896                case 0x50:
16897                case 0x60:
16898                case 0x70:
16899                case 0x80:
16900                case 0x90:
16901                case 0xa0:
16902                case 0xb0:
16903                case 0xc0:
16904                case 0xd0:
16905                case 0xe0:
16906                  goto op_semantics_139;
16907                  break;
16908                case 0xf0:
16909                  goto op_semantics_140;
16910                  break;
16911              }
16912            break;
16913          case 0xf6:
16914              GETBYTE ();
16915              switch (op[2] & 0xf0)
16916              {
16917                case 0x00:
16918                case 0x10:
16919                case 0x20:
16920                case 0x30:
16921                case 0x40:
16922                case 0x50:
16923                case 0x60:
16924                case 0x70:
16925                case 0x80:
16926                case 0x90:
16927                case 0xa0:
16928                case 0xb0:
16929                case 0xc0:
16930                case 0xd0:
16931                case 0xe0:
16932                  goto op_semantics_139;
16933                  break;
16934                case 0xf0:
16935                  goto op_semantics_140;
16936                  break;
16937              }
16938            break;
16939          case 0xf7:
16940              GETBYTE ();
16941              switch (op[2] & 0xf0)
16942              {
16943                case 0x00:
16944                case 0x10:
16945                case 0x20:
16946                case 0x30:
16947                case 0x40:
16948                case 0x50:
16949                case 0x60:
16950                case 0x70:
16951                case 0x80:
16952                case 0x90:
16953                case 0xa0:
16954                case 0xb0:
16955                case 0xc0:
16956                case 0xd0:
16957                case 0xe0:
16958                  goto op_semantics_139;
16959                  break;
16960                case 0xf0:
16961                  goto op_semantics_140;
16962                  break;
16963              }
16964            break;
16965          case 0xf8:
16966              GETBYTE ();
16967              switch (op[2] & 0xf0)
16968              {
16969                case 0x00:
16970                case 0x10:
16971                case 0x20:
16972                case 0x30:
16973                case 0x40:
16974                case 0x50:
16975                case 0x60:
16976                case 0x70:
16977                case 0x80:
16978                case 0x90:
16979                case 0xa0:
16980                case 0xb0:
16981                case 0xc0:
16982                case 0xd0:
16983                case 0xe0:
16984                  goto op_semantics_139;
16985                  break;
16986                case 0xf0:
16987                  goto op_semantics_140;
16988                  break;
16989              }
16990            break;
16991          case 0xf9:
16992              GETBYTE ();
16993              switch (op[2] & 0xf0)
16994              {
16995                case 0x00:
16996                case 0x10:
16997                case 0x20:
16998                case 0x30:
16999                case 0x40:
17000                case 0x50:
17001                case 0x60:
17002                case 0x70:
17003                case 0x80:
17004                case 0x90:
17005                case 0xa0:
17006                case 0xb0:
17007                case 0xc0:
17008                case 0xd0:
17009                case 0xe0:
17010                  goto op_semantics_139;
17011                  break;
17012                case 0xf0:
17013                  goto op_semantics_140;
17014                  break;
17015              }
17016            break;
17017          case 0xfa:
17018              GETBYTE ();
17019              switch (op[2] & 0xf0)
17020              {
17021                case 0x00:
17022                case 0x10:
17023                case 0x20:
17024                case 0x30:
17025                case 0x40:
17026                case 0x50:
17027                case 0x60:
17028                case 0x70:
17029                case 0x80:
17030                case 0x90:
17031                case 0xa0:
17032                case 0xb0:
17033                case 0xc0:
17034                case 0xd0:
17035                case 0xe0:
17036                  goto op_semantics_139;
17037                  break;
17038                case 0xf0:
17039                  goto op_semantics_140;
17040                  break;
17041              }
17042            break;
17043          case 0xfb:
17044              GETBYTE ();
17045              switch (op[2] & 0xf0)
17046              {
17047                case 0x00:
17048                case 0x10:
17049                case 0x20:
17050                case 0x30:
17051                case 0x40:
17052                case 0x50:
17053                case 0x60:
17054                case 0x70:
17055                case 0x80:
17056                case 0x90:
17057                case 0xa0:
17058                case 0xb0:
17059                case 0xc0:
17060                case 0xd0:
17061                case 0xe0:
17062                  goto op_semantics_139;
17063                  break;
17064                case 0xf0:
17065                  goto op_semantics_140;
17066                  break;
17067              }
17068            break;
17069          case 0xfc:
17070              GETBYTE ();
17071              switch (op[2] & 0xf0)
17072              {
17073                case 0x00:
17074                case 0x10:
17075                case 0x20:
17076                case 0x30:
17077                case 0x40:
17078                case 0x50:
17079                case 0x60:
17080                case 0x70:
17081                case 0x80:
17082                case 0x90:
17083                case 0xa0:
17084                case 0xb0:
17085                case 0xc0:
17086                case 0xd0:
17087                case 0xe0:
17088                  goto op_semantics_139;
17089                  break;
17090                case 0xf0:
17091                  goto op_semantics_140;
17092                  break;
17093              }
17094            break;
17095          case 0xfd:
17096              GETBYTE ();
17097              switch (op[2] & 0xf0)
17098              {
17099                case 0x00:
17100                case 0x10:
17101                case 0x20:
17102                case 0x30:
17103                case 0x40:
17104                case 0x50:
17105                case 0x60:
17106                case 0x70:
17107                case 0x80:
17108                case 0x90:
17109                case 0xa0:
17110                case 0xb0:
17111                case 0xc0:
17112                case 0xd0:
17113                case 0xe0:
17114                  goto op_semantics_139;
17115                  break;
17116                case 0xf0:
17117                  goto op_semantics_140;
17118                  break;
17119              }
17120            break;
17121          case 0xfe:
17122              GETBYTE ();
17123              switch (op[2] & 0xf0)
17124              {
17125                case 0x00:
17126                case 0x10:
17127                case 0x20:
17128                case 0x30:
17129                case 0x40:
17130                case 0x50:
17131                case 0x60:
17132                case 0x70:
17133                case 0x80:
17134                case 0x90:
17135                case 0xa0:
17136                case 0xb0:
17137                case 0xc0:
17138                case 0xd0:
17139                case 0xe0:
17140                  goto op_semantics_139;
17141                  break;
17142                case 0xf0:
17143                  goto op_semantics_140;
17144                  break;
17145              }
17146            break;
17147          case 0xff:
17148              GETBYTE ();
17149              switch (op[2] & 0xf0)
17150              {
17151                case 0x00:
17152                case 0x10:
17153                case 0x20:
17154                case 0x30:
17155                case 0x40:
17156                case 0x50:
17157                case 0x60:
17158                case 0x70:
17159                case 0x80:
17160                case 0x90:
17161                case 0xa0:
17162                case 0xb0:
17163                case 0xc0:
17164                case 0xd0:
17165                case 0xe0:
17166                  goto op_semantics_139;
17167                  break;
17168                case 0xf0:
17169                  goto op_semantics_140;
17170                  break;
17171              }
17172            break;
17173          default: UNSUPPORTED(); break;
17174        }
17175      break;
17176    case 0xfe:
17177        GETBYTE ();
17178        switch (op[1] & 0xff)
17179        {
17180          case 0x00:
17181              GETBYTE ();
17182              switch (op[2] & 0x00)
17183              {
17184                case 0x00:
17185                  op_semantics_141:
17186                    {
17187                      /** 1111 1110 00sz isrc bsrc rdst	mov%s	%0, [%1, %2] */
17188#line 363 "rx-decode.opc"
17189                      int sz AU = (op[1] >> 4) & 0x03;
17190#line 363 "rx-decode.opc"
17191                      int isrc AU = op[1] & 0x0f;
17192#line 363 "rx-decode.opc"
17193                      int bsrc AU = (op[2] >> 4) & 0x0f;
17194#line 363 "rx-decode.opc"
17195                      int rdst AU = op[2] & 0x0f;
17196                      if (trace)
17197                        {
17198                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17199                                 "/** 1111 1110 00sz isrc bsrc rdst	mov%s	%0, [%1, %2] */",
17200                                 op[0], op[1], op[2]);
17201                          printf ("  sz = 0x%x,", sz);
17202                          printf ("  isrc = 0x%x,", isrc);
17203                          printf ("  bsrc = 0x%x,", bsrc);
17204                          printf ("  rdst = 0x%x\n", rdst);
17205                        }
17206                      SYNTAX("mov%s	%0, [%1, %2]");
17207#line 363 "rx-decode.opc"
17208                      ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17209
17210                    }
17211                  break;
17212              }
17213            break;
17214          case 0x01:
17215              GETBYTE ();
17216              switch (op[2] & 0x00)
17217              {
17218                case 0x00:
17219                  goto op_semantics_141;
17220                  break;
17221              }
17222            break;
17223          case 0x02:
17224              GETBYTE ();
17225              switch (op[2] & 0x00)
17226              {
17227                case 0x00:
17228                  goto op_semantics_141;
17229                  break;
17230              }
17231            break;
17232          case 0x03:
17233              GETBYTE ();
17234              switch (op[2] & 0x00)
17235              {
17236                case 0x00:
17237                  goto op_semantics_141;
17238                  break;
17239              }
17240            break;
17241          case 0x04:
17242              GETBYTE ();
17243              switch (op[2] & 0x00)
17244              {
17245                case 0x00:
17246                  goto op_semantics_141;
17247                  break;
17248              }
17249            break;
17250          case 0x05:
17251              GETBYTE ();
17252              switch (op[2] & 0x00)
17253              {
17254                case 0x00:
17255                  goto op_semantics_141;
17256                  break;
17257              }
17258            break;
17259          case 0x06:
17260              GETBYTE ();
17261              switch (op[2] & 0x00)
17262              {
17263                case 0x00:
17264                  goto op_semantics_141;
17265                  break;
17266              }
17267            break;
17268          case 0x07:
17269              GETBYTE ();
17270              switch (op[2] & 0x00)
17271              {
17272                case 0x00:
17273                  goto op_semantics_141;
17274                  break;
17275              }
17276            break;
17277          case 0x08:
17278              GETBYTE ();
17279              switch (op[2] & 0x00)
17280              {
17281                case 0x00:
17282                  goto op_semantics_141;
17283                  break;
17284              }
17285            break;
17286          case 0x09:
17287              GETBYTE ();
17288              switch (op[2] & 0x00)
17289              {
17290                case 0x00:
17291                  goto op_semantics_141;
17292                  break;
17293              }
17294            break;
17295          case 0x0a:
17296              GETBYTE ();
17297              switch (op[2] & 0x00)
17298              {
17299                case 0x00:
17300                  goto op_semantics_141;
17301                  break;
17302              }
17303            break;
17304          case 0x0b:
17305              GETBYTE ();
17306              switch (op[2] & 0x00)
17307              {
17308                case 0x00:
17309                  goto op_semantics_141;
17310                  break;
17311              }
17312            break;
17313          case 0x0c:
17314              GETBYTE ();
17315              switch (op[2] & 0x00)
17316              {
17317                case 0x00:
17318                  goto op_semantics_141;
17319                  break;
17320              }
17321            break;
17322          case 0x0d:
17323              GETBYTE ();
17324              switch (op[2] & 0x00)
17325              {
17326                case 0x00:
17327                  goto op_semantics_141;
17328                  break;
17329              }
17330            break;
17331          case 0x0e:
17332              GETBYTE ();
17333              switch (op[2] & 0x00)
17334              {
17335                case 0x00:
17336                  goto op_semantics_141;
17337                  break;
17338              }
17339            break;
17340          case 0x0f:
17341              GETBYTE ();
17342              switch (op[2] & 0x00)
17343              {
17344                case 0x00:
17345                  goto op_semantics_141;
17346                  break;
17347              }
17348            break;
17349          case 0x10:
17350              GETBYTE ();
17351              switch (op[2] & 0x00)
17352              {
17353                case 0x00:
17354                  goto op_semantics_141;
17355                  break;
17356              }
17357            break;
17358          case 0x11:
17359              GETBYTE ();
17360              switch (op[2] & 0x00)
17361              {
17362                case 0x00:
17363                  goto op_semantics_141;
17364                  break;
17365              }
17366            break;
17367          case 0x12:
17368              GETBYTE ();
17369              switch (op[2] & 0x00)
17370              {
17371                case 0x00:
17372                  goto op_semantics_141;
17373                  break;
17374              }
17375            break;
17376          case 0x13:
17377              GETBYTE ();
17378              switch (op[2] & 0x00)
17379              {
17380                case 0x00:
17381                  goto op_semantics_141;
17382                  break;
17383              }
17384            break;
17385          case 0x14:
17386              GETBYTE ();
17387              switch (op[2] & 0x00)
17388              {
17389                case 0x00:
17390                  goto op_semantics_141;
17391                  break;
17392              }
17393            break;
17394          case 0x15:
17395              GETBYTE ();
17396              switch (op[2] & 0x00)
17397              {
17398                case 0x00:
17399                  goto op_semantics_141;
17400                  break;
17401              }
17402            break;
17403          case 0x16:
17404              GETBYTE ();
17405              switch (op[2] & 0x00)
17406              {
17407                case 0x00:
17408                  goto op_semantics_141;
17409                  break;
17410              }
17411            break;
17412          case 0x17:
17413              GETBYTE ();
17414              switch (op[2] & 0x00)
17415              {
17416                case 0x00:
17417                  goto op_semantics_141;
17418                  break;
17419              }
17420            break;
17421          case 0x18:
17422              GETBYTE ();
17423              switch (op[2] & 0x00)
17424              {
17425                case 0x00:
17426                  goto op_semantics_141;
17427                  break;
17428              }
17429            break;
17430          case 0x19:
17431              GETBYTE ();
17432              switch (op[2] & 0x00)
17433              {
17434                case 0x00:
17435                  goto op_semantics_141;
17436                  break;
17437              }
17438            break;
17439          case 0x1a:
17440              GETBYTE ();
17441              switch (op[2] & 0x00)
17442              {
17443                case 0x00:
17444                  goto op_semantics_141;
17445                  break;
17446              }
17447            break;
17448          case 0x1b:
17449              GETBYTE ();
17450              switch (op[2] & 0x00)
17451              {
17452                case 0x00:
17453                  goto op_semantics_141;
17454                  break;
17455              }
17456            break;
17457          case 0x1c:
17458              GETBYTE ();
17459              switch (op[2] & 0x00)
17460              {
17461                case 0x00:
17462                  goto op_semantics_141;
17463                  break;
17464              }
17465            break;
17466          case 0x1d:
17467              GETBYTE ();
17468              switch (op[2] & 0x00)
17469              {
17470                case 0x00:
17471                  goto op_semantics_141;
17472                  break;
17473              }
17474            break;
17475          case 0x1e:
17476              GETBYTE ();
17477              switch (op[2] & 0x00)
17478              {
17479                case 0x00:
17480                  goto op_semantics_141;
17481                  break;
17482              }
17483            break;
17484          case 0x1f:
17485              GETBYTE ();
17486              switch (op[2] & 0x00)
17487              {
17488                case 0x00:
17489                  goto op_semantics_141;
17490                  break;
17491              }
17492            break;
17493          case 0x20:
17494              GETBYTE ();
17495              switch (op[2] & 0x00)
17496              {
17497                case 0x00:
17498                  goto op_semantics_141;
17499                  break;
17500              }
17501            break;
17502          case 0x21:
17503              GETBYTE ();
17504              switch (op[2] & 0x00)
17505              {
17506                case 0x00:
17507                  goto op_semantics_141;
17508                  break;
17509              }
17510            break;
17511          case 0x22:
17512              GETBYTE ();
17513              switch (op[2] & 0x00)
17514              {
17515                case 0x00:
17516                  goto op_semantics_141;
17517                  break;
17518              }
17519            break;
17520          case 0x23:
17521              GETBYTE ();
17522              switch (op[2] & 0x00)
17523              {
17524                case 0x00:
17525                  goto op_semantics_141;
17526                  break;
17527              }
17528            break;
17529          case 0x24:
17530              GETBYTE ();
17531              switch (op[2] & 0x00)
17532              {
17533                case 0x00:
17534                  goto op_semantics_141;
17535                  break;
17536              }
17537            break;
17538          case 0x25:
17539              GETBYTE ();
17540              switch (op[2] & 0x00)
17541              {
17542                case 0x00:
17543                  goto op_semantics_141;
17544                  break;
17545              }
17546            break;
17547          case 0x26:
17548              GETBYTE ();
17549              switch (op[2] & 0x00)
17550              {
17551                case 0x00:
17552                  goto op_semantics_141;
17553                  break;
17554              }
17555            break;
17556          case 0x27:
17557              GETBYTE ();
17558              switch (op[2] & 0x00)
17559              {
17560                case 0x00:
17561                  goto op_semantics_141;
17562                  break;
17563              }
17564            break;
17565          case 0x28:
17566              GETBYTE ();
17567              switch (op[2] & 0x00)
17568              {
17569                case 0x00:
17570                  goto op_semantics_141;
17571                  break;
17572              }
17573            break;
17574          case 0x29:
17575              GETBYTE ();
17576              switch (op[2] & 0x00)
17577              {
17578                case 0x00:
17579                  goto op_semantics_141;
17580                  break;
17581              }
17582            break;
17583          case 0x2a:
17584              GETBYTE ();
17585              switch (op[2] & 0x00)
17586              {
17587                case 0x00:
17588                  goto op_semantics_141;
17589                  break;
17590              }
17591            break;
17592          case 0x2b:
17593              GETBYTE ();
17594              switch (op[2] & 0x00)
17595              {
17596                case 0x00:
17597                  goto op_semantics_141;
17598                  break;
17599              }
17600            break;
17601          case 0x2c:
17602              GETBYTE ();
17603              switch (op[2] & 0x00)
17604              {
17605                case 0x00:
17606                  goto op_semantics_141;
17607                  break;
17608              }
17609            break;
17610          case 0x2d:
17611              GETBYTE ();
17612              switch (op[2] & 0x00)
17613              {
17614                case 0x00:
17615                  goto op_semantics_141;
17616                  break;
17617              }
17618            break;
17619          case 0x2e:
17620              GETBYTE ();
17621              switch (op[2] & 0x00)
17622              {
17623                case 0x00:
17624                  goto op_semantics_141;
17625                  break;
17626              }
17627            break;
17628          case 0x2f:
17629              GETBYTE ();
17630              switch (op[2] & 0x00)
17631              {
17632                case 0x00:
17633                  goto op_semantics_141;
17634                  break;
17635              }
17636            break;
17637          case 0x40:
17638              GETBYTE ();
17639              switch (op[2] & 0x00)
17640              {
17641                case 0x00:
17642                  op_semantics_142:
17643                    {
17644                      /** 1111 1110 01sz isrc bsrc rdst	mov%s	[%1, %2], %0 */
17645#line 360 "rx-decode.opc"
17646                      int sz AU = (op[1] >> 4) & 0x03;
17647#line 360 "rx-decode.opc"
17648                      int isrc AU = op[1] & 0x0f;
17649#line 360 "rx-decode.opc"
17650                      int bsrc AU = (op[2] >> 4) & 0x0f;
17651#line 360 "rx-decode.opc"
17652                      int rdst AU = op[2] & 0x0f;
17653                      if (trace)
17654                        {
17655                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17656                                 "/** 1111 1110 01sz isrc bsrc rdst	mov%s	[%1, %2], %0 */",
17657                                 op[0], op[1], op[2]);
17658                          printf ("  sz = 0x%x,", sz);
17659                          printf ("  isrc = 0x%x,", isrc);
17660                          printf ("  bsrc = 0x%x,", bsrc);
17661                          printf ("  rdst = 0x%x\n", rdst);
17662                        }
17663                      SYNTAX("mov%s	[%1, %2], %0");
17664#line 360 "rx-decode.opc"
17665                      ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17666
17667                    }
17668                  break;
17669              }
17670            break;
17671          case 0x41:
17672              GETBYTE ();
17673              switch (op[2] & 0x00)
17674              {
17675                case 0x00:
17676                  goto op_semantics_142;
17677                  break;
17678              }
17679            break;
17680          case 0x42:
17681              GETBYTE ();
17682              switch (op[2] & 0x00)
17683              {
17684                case 0x00:
17685                  goto op_semantics_142;
17686                  break;
17687              }
17688            break;
17689          case 0x43:
17690              GETBYTE ();
17691              switch (op[2] & 0x00)
17692              {
17693                case 0x00:
17694                  goto op_semantics_142;
17695                  break;
17696              }
17697            break;
17698          case 0x44:
17699              GETBYTE ();
17700              switch (op[2] & 0x00)
17701              {
17702                case 0x00:
17703                  goto op_semantics_142;
17704                  break;
17705              }
17706            break;
17707          case 0x45:
17708              GETBYTE ();
17709              switch (op[2] & 0x00)
17710              {
17711                case 0x00:
17712                  goto op_semantics_142;
17713                  break;
17714              }
17715            break;
17716          case 0x46:
17717              GETBYTE ();
17718              switch (op[2] & 0x00)
17719              {
17720                case 0x00:
17721                  goto op_semantics_142;
17722                  break;
17723              }
17724            break;
17725          case 0x47:
17726              GETBYTE ();
17727              switch (op[2] & 0x00)
17728              {
17729                case 0x00:
17730                  goto op_semantics_142;
17731                  break;
17732              }
17733            break;
17734          case 0x48:
17735              GETBYTE ();
17736              switch (op[2] & 0x00)
17737              {
17738                case 0x00:
17739                  goto op_semantics_142;
17740                  break;
17741              }
17742            break;
17743          case 0x49:
17744              GETBYTE ();
17745              switch (op[2] & 0x00)
17746              {
17747                case 0x00:
17748                  goto op_semantics_142;
17749                  break;
17750              }
17751            break;
17752          case 0x4a:
17753              GETBYTE ();
17754              switch (op[2] & 0x00)
17755              {
17756                case 0x00:
17757                  goto op_semantics_142;
17758                  break;
17759              }
17760            break;
17761          case 0x4b:
17762              GETBYTE ();
17763              switch (op[2] & 0x00)
17764              {
17765                case 0x00:
17766                  goto op_semantics_142;
17767                  break;
17768              }
17769            break;
17770          case 0x4c:
17771              GETBYTE ();
17772              switch (op[2] & 0x00)
17773              {
17774                case 0x00:
17775                  goto op_semantics_142;
17776                  break;
17777              }
17778            break;
17779          case 0x4d:
17780              GETBYTE ();
17781              switch (op[2] & 0x00)
17782              {
17783                case 0x00:
17784                  goto op_semantics_142;
17785                  break;
17786              }
17787            break;
17788          case 0x4e:
17789              GETBYTE ();
17790              switch (op[2] & 0x00)
17791              {
17792                case 0x00:
17793                  goto op_semantics_142;
17794                  break;
17795              }
17796            break;
17797          case 0x4f:
17798              GETBYTE ();
17799              switch (op[2] & 0x00)
17800              {
17801                case 0x00:
17802                  goto op_semantics_142;
17803                  break;
17804              }
17805            break;
17806          case 0x50:
17807              GETBYTE ();
17808              switch (op[2] & 0x00)
17809              {
17810                case 0x00:
17811                  goto op_semantics_142;
17812                  break;
17813              }
17814            break;
17815          case 0x51:
17816              GETBYTE ();
17817              switch (op[2] & 0x00)
17818              {
17819                case 0x00:
17820                  goto op_semantics_142;
17821                  break;
17822              }
17823            break;
17824          case 0x52:
17825              GETBYTE ();
17826              switch (op[2] & 0x00)
17827              {
17828                case 0x00:
17829                  goto op_semantics_142;
17830                  break;
17831              }
17832            break;
17833          case 0x53:
17834              GETBYTE ();
17835              switch (op[2] & 0x00)
17836              {
17837                case 0x00:
17838                  goto op_semantics_142;
17839                  break;
17840              }
17841            break;
17842          case 0x54:
17843              GETBYTE ();
17844              switch (op[2] & 0x00)
17845              {
17846                case 0x00:
17847                  goto op_semantics_142;
17848                  break;
17849              }
17850            break;
17851          case 0x55:
17852              GETBYTE ();
17853              switch (op[2] & 0x00)
17854              {
17855                case 0x00:
17856                  goto op_semantics_142;
17857                  break;
17858              }
17859            break;
17860          case 0x56:
17861              GETBYTE ();
17862              switch (op[2] & 0x00)
17863              {
17864                case 0x00:
17865                  goto op_semantics_142;
17866                  break;
17867              }
17868            break;
17869          case 0x57:
17870              GETBYTE ();
17871              switch (op[2] & 0x00)
17872              {
17873                case 0x00:
17874                  goto op_semantics_142;
17875                  break;
17876              }
17877            break;
17878          case 0x58:
17879              GETBYTE ();
17880              switch (op[2] & 0x00)
17881              {
17882                case 0x00:
17883                  goto op_semantics_142;
17884                  break;
17885              }
17886            break;
17887          case 0x59:
17888              GETBYTE ();
17889              switch (op[2] & 0x00)
17890              {
17891                case 0x00:
17892                  goto op_semantics_142;
17893                  break;
17894              }
17895            break;
17896          case 0x5a:
17897              GETBYTE ();
17898              switch (op[2] & 0x00)
17899              {
17900                case 0x00:
17901                  goto op_semantics_142;
17902                  break;
17903              }
17904            break;
17905          case 0x5b:
17906              GETBYTE ();
17907              switch (op[2] & 0x00)
17908              {
17909                case 0x00:
17910                  goto op_semantics_142;
17911                  break;
17912              }
17913            break;
17914          case 0x5c:
17915              GETBYTE ();
17916              switch (op[2] & 0x00)
17917              {
17918                case 0x00:
17919                  goto op_semantics_142;
17920                  break;
17921              }
17922            break;
17923          case 0x5d:
17924              GETBYTE ();
17925              switch (op[2] & 0x00)
17926              {
17927                case 0x00:
17928                  goto op_semantics_142;
17929                  break;
17930              }
17931            break;
17932          case 0x5e:
17933              GETBYTE ();
17934              switch (op[2] & 0x00)
17935              {
17936                case 0x00:
17937                  goto op_semantics_142;
17938                  break;
17939              }
17940            break;
17941          case 0x5f:
17942              GETBYTE ();
17943              switch (op[2] & 0x00)
17944              {
17945                case 0x00:
17946                  goto op_semantics_142;
17947                  break;
17948              }
17949            break;
17950          case 0x60:
17951              GETBYTE ();
17952              switch (op[2] & 0x00)
17953              {
17954                case 0x00:
17955                  goto op_semantics_142;
17956                  break;
17957              }
17958            break;
17959          case 0x61:
17960              GETBYTE ();
17961              switch (op[2] & 0x00)
17962              {
17963                case 0x00:
17964                  goto op_semantics_142;
17965                  break;
17966              }
17967            break;
17968          case 0x62:
17969              GETBYTE ();
17970              switch (op[2] & 0x00)
17971              {
17972                case 0x00:
17973                  goto op_semantics_142;
17974                  break;
17975              }
17976            break;
17977          case 0x63:
17978              GETBYTE ();
17979              switch (op[2] & 0x00)
17980              {
17981                case 0x00:
17982                  goto op_semantics_142;
17983                  break;
17984              }
17985            break;
17986          case 0x64:
17987              GETBYTE ();
17988              switch (op[2] & 0x00)
17989              {
17990                case 0x00:
17991                  goto op_semantics_142;
17992                  break;
17993              }
17994            break;
17995          case 0x65:
17996              GETBYTE ();
17997              switch (op[2] & 0x00)
17998              {
17999                case 0x00:
18000                  goto op_semantics_142;
18001                  break;
18002              }
18003            break;
18004          case 0x66:
18005              GETBYTE ();
18006              switch (op[2] & 0x00)
18007              {
18008                case 0x00:
18009                  goto op_semantics_142;
18010                  break;
18011              }
18012            break;
18013          case 0x67:
18014              GETBYTE ();
18015              switch (op[2] & 0x00)
18016              {
18017                case 0x00:
18018                  goto op_semantics_142;
18019                  break;
18020              }
18021            break;
18022          case 0x68:
18023              GETBYTE ();
18024              switch (op[2] & 0x00)
18025              {
18026                case 0x00:
18027                  goto op_semantics_142;
18028                  break;
18029              }
18030            break;
18031          case 0x69:
18032              GETBYTE ();
18033              switch (op[2] & 0x00)
18034              {
18035                case 0x00:
18036                  goto op_semantics_142;
18037                  break;
18038              }
18039            break;
18040          case 0x6a:
18041              GETBYTE ();
18042              switch (op[2] & 0x00)
18043              {
18044                case 0x00:
18045                  goto op_semantics_142;
18046                  break;
18047              }
18048            break;
18049          case 0x6b:
18050              GETBYTE ();
18051              switch (op[2] & 0x00)
18052              {
18053                case 0x00:
18054                  goto op_semantics_142;
18055                  break;
18056              }
18057            break;
18058          case 0x6c:
18059              GETBYTE ();
18060              switch (op[2] & 0x00)
18061              {
18062                case 0x00:
18063                  goto op_semantics_142;
18064                  break;
18065              }
18066            break;
18067          case 0x6d:
18068              GETBYTE ();
18069              switch (op[2] & 0x00)
18070              {
18071                case 0x00:
18072                  goto op_semantics_142;
18073                  break;
18074              }
18075            break;
18076          case 0x6e:
18077              GETBYTE ();
18078              switch (op[2] & 0x00)
18079              {
18080                case 0x00:
18081                  goto op_semantics_142;
18082                  break;
18083              }
18084            break;
18085          case 0x6f:
18086              GETBYTE ();
18087              switch (op[2] & 0x00)
18088              {
18089                case 0x00:
18090                  goto op_semantics_142;
18091                  break;
18092              }
18093            break;
18094          case 0xc0:
18095              GETBYTE ();
18096              switch (op[2] & 0x00)
18097              {
18098                case 0x00:
18099                  op_semantics_143:
18100                    {
18101                      /** 1111 1110 11sz isrc bsrc rdst	movu%s	[%1, %2], %0 */
18102#line 366 "rx-decode.opc"
18103                      int sz AU = (op[1] >> 4) & 0x03;
18104#line 366 "rx-decode.opc"
18105                      int isrc AU = op[1] & 0x0f;
18106#line 366 "rx-decode.opc"
18107                      int bsrc AU = (op[2] >> 4) & 0x0f;
18108#line 366 "rx-decode.opc"
18109                      int rdst AU = op[2] & 0x0f;
18110                      if (trace)
18111                        {
18112                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18113                                 "/** 1111 1110 11sz isrc bsrc rdst	movu%s	[%1, %2], %0 */",
18114                                 op[0], op[1], op[2]);
18115                          printf ("  sz = 0x%x,", sz);
18116                          printf ("  isrc = 0x%x,", isrc);
18117                          printf ("  bsrc = 0x%x,", bsrc);
18118                          printf ("  rdst = 0x%x\n", rdst);
18119                        }
18120                      SYNTAX("movu%s	[%1, %2], %0");
18121#line 366 "rx-decode.opc"
18122                      ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
18123
18124                    }
18125                  break;
18126              }
18127            break;
18128          case 0xc1:
18129              GETBYTE ();
18130              switch (op[2] & 0x00)
18131              {
18132                case 0x00:
18133                  goto op_semantics_143;
18134                  break;
18135              }
18136            break;
18137          case 0xc2:
18138              GETBYTE ();
18139              switch (op[2] & 0x00)
18140              {
18141                case 0x00:
18142                  goto op_semantics_143;
18143                  break;
18144              }
18145            break;
18146          case 0xc3:
18147              GETBYTE ();
18148              switch (op[2] & 0x00)
18149              {
18150                case 0x00:
18151                  goto op_semantics_143;
18152                  break;
18153              }
18154            break;
18155          case 0xc4:
18156              GETBYTE ();
18157              switch (op[2] & 0x00)
18158              {
18159                case 0x00:
18160                  goto op_semantics_143;
18161                  break;
18162              }
18163            break;
18164          case 0xc5:
18165              GETBYTE ();
18166              switch (op[2] & 0x00)
18167              {
18168                case 0x00:
18169                  goto op_semantics_143;
18170                  break;
18171              }
18172            break;
18173          case 0xc6:
18174              GETBYTE ();
18175              switch (op[2] & 0x00)
18176              {
18177                case 0x00:
18178                  goto op_semantics_143;
18179                  break;
18180              }
18181            break;
18182          case 0xc7:
18183              GETBYTE ();
18184              switch (op[2] & 0x00)
18185              {
18186                case 0x00:
18187                  goto op_semantics_143;
18188                  break;
18189              }
18190            break;
18191          case 0xc8:
18192              GETBYTE ();
18193              switch (op[2] & 0x00)
18194              {
18195                case 0x00:
18196                  goto op_semantics_143;
18197                  break;
18198              }
18199            break;
18200          case 0xc9:
18201              GETBYTE ();
18202              switch (op[2] & 0x00)
18203              {
18204                case 0x00:
18205                  goto op_semantics_143;
18206                  break;
18207              }
18208            break;
18209          case 0xca:
18210              GETBYTE ();
18211              switch (op[2] & 0x00)
18212              {
18213                case 0x00:
18214                  goto op_semantics_143;
18215                  break;
18216              }
18217            break;
18218          case 0xcb:
18219              GETBYTE ();
18220              switch (op[2] & 0x00)
18221              {
18222                case 0x00:
18223                  goto op_semantics_143;
18224                  break;
18225              }
18226            break;
18227          case 0xcc:
18228              GETBYTE ();
18229              switch (op[2] & 0x00)
18230              {
18231                case 0x00:
18232                  goto op_semantics_143;
18233                  break;
18234              }
18235            break;
18236          case 0xcd:
18237              GETBYTE ();
18238              switch (op[2] & 0x00)
18239              {
18240                case 0x00:
18241                  goto op_semantics_143;
18242                  break;
18243              }
18244            break;
18245          case 0xce:
18246              GETBYTE ();
18247              switch (op[2] & 0x00)
18248              {
18249                case 0x00:
18250                  goto op_semantics_143;
18251                  break;
18252              }
18253            break;
18254          case 0xcf:
18255              GETBYTE ();
18256              switch (op[2] & 0x00)
18257              {
18258                case 0x00:
18259                  goto op_semantics_143;
18260                  break;
18261              }
18262            break;
18263          case 0xd0:
18264              GETBYTE ();
18265              switch (op[2] & 0x00)
18266              {
18267                case 0x00:
18268                  goto op_semantics_143;
18269                  break;
18270              }
18271            break;
18272          case 0xd1:
18273              GETBYTE ();
18274              switch (op[2] & 0x00)
18275              {
18276                case 0x00:
18277                  goto op_semantics_143;
18278                  break;
18279              }
18280            break;
18281          case 0xd2:
18282              GETBYTE ();
18283              switch (op[2] & 0x00)
18284              {
18285                case 0x00:
18286                  goto op_semantics_143;
18287                  break;
18288              }
18289            break;
18290          case 0xd3:
18291              GETBYTE ();
18292              switch (op[2] & 0x00)
18293              {
18294                case 0x00:
18295                  goto op_semantics_143;
18296                  break;
18297              }
18298            break;
18299          case 0xd4:
18300              GETBYTE ();
18301              switch (op[2] & 0x00)
18302              {
18303                case 0x00:
18304                  goto op_semantics_143;
18305                  break;
18306              }
18307            break;
18308          case 0xd5:
18309              GETBYTE ();
18310              switch (op[2] & 0x00)
18311              {
18312                case 0x00:
18313                  goto op_semantics_143;
18314                  break;
18315              }
18316            break;
18317          case 0xd6:
18318              GETBYTE ();
18319              switch (op[2] & 0x00)
18320              {
18321                case 0x00:
18322                  goto op_semantics_143;
18323                  break;
18324              }
18325            break;
18326          case 0xd7:
18327              GETBYTE ();
18328              switch (op[2] & 0x00)
18329              {
18330                case 0x00:
18331                  goto op_semantics_143;
18332                  break;
18333              }
18334            break;
18335          case 0xd8:
18336              GETBYTE ();
18337              switch (op[2] & 0x00)
18338              {
18339                case 0x00:
18340                  goto op_semantics_143;
18341                  break;
18342              }
18343            break;
18344          case 0xd9:
18345              GETBYTE ();
18346              switch (op[2] & 0x00)
18347              {
18348                case 0x00:
18349                  goto op_semantics_143;
18350                  break;
18351              }
18352            break;
18353          case 0xda:
18354              GETBYTE ();
18355              switch (op[2] & 0x00)
18356              {
18357                case 0x00:
18358                  goto op_semantics_143;
18359                  break;
18360              }
18361            break;
18362          case 0xdb:
18363              GETBYTE ();
18364              switch (op[2] & 0x00)
18365              {
18366                case 0x00:
18367                  goto op_semantics_143;
18368                  break;
18369              }
18370            break;
18371          case 0xdc:
18372              GETBYTE ();
18373              switch (op[2] & 0x00)
18374              {
18375                case 0x00:
18376                  goto op_semantics_143;
18377                  break;
18378              }
18379            break;
18380          case 0xdd:
18381              GETBYTE ();
18382              switch (op[2] & 0x00)
18383              {
18384                case 0x00:
18385                  goto op_semantics_143;
18386                  break;
18387              }
18388            break;
18389          case 0xde:
18390              GETBYTE ();
18391              switch (op[2] & 0x00)
18392              {
18393                case 0x00:
18394                  goto op_semantics_143;
18395                  break;
18396              }
18397            break;
18398          case 0xdf:
18399              GETBYTE ();
18400              switch (op[2] & 0x00)
18401              {
18402                case 0x00:
18403                  goto op_semantics_143;
18404                  break;
18405              }
18406            break;
18407          case 0xe0:
18408              GETBYTE ();
18409              switch (op[2] & 0x00)
18410              {
18411                case 0x00:
18412                  goto op_semantics_143;
18413                  break;
18414              }
18415            break;
18416          case 0xe1:
18417              GETBYTE ();
18418              switch (op[2] & 0x00)
18419              {
18420                case 0x00:
18421                  goto op_semantics_143;
18422                  break;
18423              }
18424            break;
18425          case 0xe2:
18426              GETBYTE ();
18427              switch (op[2] & 0x00)
18428              {
18429                case 0x00:
18430                  goto op_semantics_143;
18431                  break;
18432              }
18433            break;
18434          case 0xe3:
18435              GETBYTE ();
18436              switch (op[2] & 0x00)
18437              {
18438                case 0x00:
18439                  goto op_semantics_143;
18440                  break;
18441              }
18442            break;
18443          case 0xe4:
18444              GETBYTE ();
18445              switch (op[2] & 0x00)
18446              {
18447                case 0x00:
18448                  goto op_semantics_143;
18449                  break;
18450              }
18451            break;
18452          case 0xe5:
18453              GETBYTE ();
18454              switch (op[2] & 0x00)
18455              {
18456                case 0x00:
18457                  goto op_semantics_143;
18458                  break;
18459              }
18460            break;
18461          case 0xe6:
18462              GETBYTE ();
18463              switch (op[2] & 0x00)
18464              {
18465                case 0x00:
18466                  goto op_semantics_143;
18467                  break;
18468              }
18469            break;
18470          case 0xe7:
18471              GETBYTE ();
18472              switch (op[2] & 0x00)
18473              {
18474                case 0x00:
18475                  goto op_semantics_143;
18476                  break;
18477              }
18478            break;
18479          case 0xe8:
18480              GETBYTE ();
18481              switch (op[2] & 0x00)
18482              {
18483                case 0x00:
18484                  goto op_semantics_143;
18485                  break;
18486              }
18487            break;
18488          case 0xe9:
18489              GETBYTE ();
18490              switch (op[2] & 0x00)
18491              {
18492                case 0x00:
18493                  goto op_semantics_143;
18494                  break;
18495              }
18496            break;
18497          case 0xea:
18498              GETBYTE ();
18499              switch (op[2] & 0x00)
18500              {
18501                case 0x00:
18502                  goto op_semantics_143;
18503                  break;
18504              }
18505            break;
18506          case 0xeb:
18507              GETBYTE ();
18508              switch (op[2] & 0x00)
18509              {
18510                case 0x00:
18511                  goto op_semantics_143;
18512                  break;
18513              }
18514            break;
18515          case 0xec:
18516              GETBYTE ();
18517              switch (op[2] & 0x00)
18518              {
18519                case 0x00:
18520                  goto op_semantics_143;
18521                  break;
18522              }
18523            break;
18524          case 0xed:
18525              GETBYTE ();
18526              switch (op[2] & 0x00)
18527              {
18528                case 0x00:
18529                  goto op_semantics_143;
18530                  break;
18531              }
18532            break;
18533          case 0xee:
18534              GETBYTE ();
18535              switch (op[2] & 0x00)
18536              {
18537                case 0x00:
18538                  goto op_semantics_143;
18539                  break;
18540              }
18541            break;
18542          case 0xef:
18543              GETBYTE ();
18544              switch (op[2] & 0x00)
18545              {
18546                case 0x00:
18547                  goto op_semantics_143;
18548                  break;
18549              }
18550            break;
18551          default: UNSUPPORTED(); break;
18552        }
18553      break;
18554    case 0xff:
18555        GETBYTE ();
18556        switch (op[1] & 0xff)
18557        {
18558          case 0x00:
18559              GETBYTE ();
18560              switch (op[2] & 0x00)
18561              {
18562                case 0x00:
18563                  op_semantics_144:
18564                    {
18565                      /** 1111 1111 0000 rdst srca srcb	sub	%2, %1, %0 */
18566#line 570 "rx-decode.opc"
18567                      int rdst AU = op[1] & 0x0f;
18568#line 570 "rx-decode.opc"
18569                      int srca AU = (op[2] >> 4) & 0x0f;
18570#line 570 "rx-decode.opc"
18571                      int srcb AU = op[2] & 0x0f;
18572                      if (trace)
18573                        {
18574                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18575                                 "/** 1111 1111 0000 rdst srca srcb	sub	%2, %1, %0 */",
18576                                 op[0], op[1], op[2]);
18577                          printf ("  rdst = 0x%x,", rdst);
18578                          printf ("  srca = 0x%x,", srca);
18579                          printf ("  srcb = 0x%x\n", srcb);
18580                        }
18581                      SYNTAX("sub	%2, %1, %0");
18582#line 570 "rx-decode.opc"
18583                      ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18584
18585                    /*----------------------------------------------------------------------*/
18586                    /* SBB									*/
18587
18588                    }
18589                  break;
18590              }
18591            break;
18592          case 0x01:
18593              GETBYTE ();
18594              switch (op[2] & 0x00)
18595              {
18596                case 0x00:
18597                  goto op_semantics_144;
18598                  break;
18599              }
18600            break;
18601          case 0x02:
18602              GETBYTE ();
18603              switch (op[2] & 0x00)
18604              {
18605                case 0x00:
18606                  goto op_semantics_144;
18607                  break;
18608              }
18609            break;
18610          case 0x03:
18611              GETBYTE ();
18612              switch (op[2] & 0x00)
18613              {
18614                case 0x00:
18615                  goto op_semantics_144;
18616                  break;
18617              }
18618            break;
18619          case 0x04:
18620              GETBYTE ();
18621              switch (op[2] & 0x00)
18622              {
18623                case 0x00:
18624                  goto op_semantics_144;
18625                  break;
18626              }
18627            break;
18628          case 0x05:
18629              GETBYTE ();
18630              switch (op[2] & 0x00)
18631              {
18632                case 0x00:
18633                  goto op_semantics_144;
18634                  break;
18635              }
18636            break;
18637          case 0x06:
18638              GETBYTE ();
18639              switch (op[2] & 0x00)
18640              {
18641                case 0x00:
18642                  goto op_semantics_144;
18643                  break;
18644              }
18645            break;
18646          case 0x07:
18647              GETBYTE ();
18648              switch (op[2] & 0x00)
18649              {
18650                case 0x00:
18651                  goto op_semantics_144;
18652                  break;
18653              }
18654            break;
18655          case 0x08:
18656              GETBYTE ();
18657              switch (op[2] & 0x00)
18658              {
18659                case 0x00:
18660                  goto op_semantics_144;
18661                  break;
18662              }
18663            break;
18664          case 0x09:
18665              GETBYTE ();
18666              switch (op[2] & 0x00)
18667              {
18668                case 0x00:
18669                  goto op_semantics_144;
18670                  break;
18671              }
18672            break;
18673          case 0x0a:
18674              GETBYTE ();
18675              switch (op[2] & 0x00)
18676              {
18677                case 0x00:
18678                  goto op_semantics_144;
18679                  break;
18680              }
18681            break;
18682          case 0x0b:
18683              GETBYTE ();
18684              switch (op[2] & 0x00)
18685              {
18686                case 0x00:
18687                  goto op_semantics_144;
18688                  break;
18689              }
18690            break;
18691          case 0x0c:
18692              GETBYTE ();
18693              switch (op[2] & 0x00)
18694              {
18695                case 0x00:
18696                  goto op_semantics_144;
18697                  break;
18698              }
18699            break;
18700          case 0x0d:
18701              GETBYTE ();
18702              switch (op[2] & 0x00)
18703              {
18704                case 0x00:
18705                  goto op_semantics_144;
18706                  break;
18707              }
18708            break;
18709          case 0x0e:
18710              GETBYTE ();
18711              switch (op[2] & 0x00)
18712              {
18713                case 0x00:
18714                  goto op_semantics_144;
18715                  break;
18716              }
18717            break;
18718          case 0x0f:
18719              GETBYTE ();
18720              switch (op[2] & 0x00)
18721              {
18722                case 0x00:
18723                  goto op_semantics_144;
18724                  break;
18725              }
18726            break;
18727          case 0x20:
18728              GETBYTE ();
18729              switch (op[2] & 0x00)
18730              {
18731                case 0x00:
18732                  op_semantics_145:
18733                    {
18734                      /** 1111 1111 0010 rdst srca srcb	add	%2, %1, %0 */
18735#line 537 "rx-decode.opc"
18736                      int rdst AU = op[1] & 0x0f;
18737#line 537 "rx-decode.opc"
18738                      int srca AU = (op[2] >> 4) & 0x0f;
18739#line 537 "rx-decode.opc"
18740                      int srcb AU = op[2] & 0x0f;
18741                      if (trace)
18742                        {
18743                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18744                                 "/** 1111 1111 0010 rdst srca srcb	add	%2, %1, %0 */",
18745                                 op[0], op[1], op[2]);
18746                          printf ("  rdst = 0x%x,", rdst);
18747                          printf ("  srca = 0x%x,", srca);
18748                          printf ("  srcb = 0x%x\n", srcb);
18749                        }
18750                      SYNTAX("add	%2, %1, %0");
18751#line 537 "rx-decode.opc"
18752                      ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18753
18754                    /*----------------------------------------------------------------------*/
18755                    /* CMP									*/
18756
18757                    }
18758                  break;
18759              }
18760            break;
18761          case 0x21:
18762              GETBYTE ();
18763              switch (op[2] & 0x00)
18764              {
18765                case 0x00:
18766                  goto op_semantics_145;
18767                  break;
18768              }
18769            break;
18770          case 0x22:
18771              GETBYTE ();
18772              switch (op[2] & 0x00)
18773              {
18774                case 0x00:
18775                  goto op_semantics_145;
18776                  break;
18777              }
18778            break;
18779          case 0x23:
18780              GETBYTE ();
18781              switch (op[2] & 0x00)
18782              {
18783                case 0x00:
18784                  goto op_semantics_145;
18785                  break;
18786              }
18787            break;
18788          case 0x24:
18789              GETBYTE ();
18790              switch (op[2] & 0x00)
18791              {
18792                case 0x00:
18793                  goto op_semantics_145;
18794                  break;
18795              }
18796            break;
18797          case 0x25:
18798              GETBYTE ();
18799              switch (op[2] & 0x00)
18800              {
18801                case 0x00:
18802                  goto op_semantics_145;
18803                  break;
18804              }
18805            break;
18806          case 0x26:
18807              GETBYTE ();
18808              switch (op[2] & 0x00)
18809              {
18810                case 0x00:
18811                  goto op_semantics_145;
18812                  break;
18813              }
18814            break;
18815          case 0x27:
18816              GETBYTE ();
18817              switch (op[2] & 0x00)
18818              {
18819                case 0x00:
18820                  goto op_semantics_145;
18821                  break;
18822              }
18823            break;
18824          case 0x28:
18825              GETBYTE ();
18826              switch (op[2] & 0x00)
18827              {
18828                case 0x00:
18829                  goto op_semantics_145;
18830                  break;
18831              }
18832            break;
18833          case 0x29:
18834              GETBYTE ();
18835              switch (op[2] & 0x00)
18836              {
18837                case 0x00:
18838                  goto op_semantics_145;
18839                  break;
18840              }
18841            break;
18842          case 0x2a:
18843              GETBYTE ();
18844              switch (op[2] & 0x00)
18845              {
18846                case 0x00:
18847                  goto op_semantics_145;
18848                  break;
18849              }
18850            break;
18851          case 0x2b:
18852              GETBYTE ();
18853              switch (op[2] & 0x00)
18854              {
18855                case 0x00:
18856                  goto op_semantics_145;
18857                  break;
18858              }
18859            break;
18860          case 0x2c:
18861              GETBYTE ();
18862              switch (op[2] & 0x00)
18863              {
18864                case 0x00:
18865                  goto op_semantics_145;
18866                  break;
18867              }
18868            break;
18869          case 0x2d:
18870              GETBYTE ();
18871              switch (op[2] & 0x00)
18872              {
18873                case 0x00:
18874                  goto op_semantics_145;
18875                  break;
18876              }
18877            break;
18878          case 0x2e:
18879              GETBYTE ();
18880              switch (op[2] & 0x00)
18881              {
18882                case 0x00:
18883                  goto op_semantics_145;
18884                  break;
18885              }
18886            break;
18887          case 0x2f:
18888              GETBYTE ();
18889              switch (op[2] & 0x00)
18890              {
18891                case 0x00:
18892                  goto op_semantics_145;
18893                  break;
18894              }
18895            break;
18896          case 0x30:
18897              GETBYTE ();
18898              switch (op[2] & 0x00)
18899              {
18900                case 0x00:
18901                  op_semantics_146:
18902                    {
18903                      /** 1111 1111 0011 rdst srca srcb	mul 	%2, %1, %0 */
18904#line 677 "rx-decode.opc"
18905                      int rdst AU = op[1] & 0x0f;
18906#line 677 "rx-decode.opc"
18907                      int srca AU = (op[2] >> 4) & 0x0f;
18908#line 677 "rx-decode.opc"
18909                      int srcb AU = op[2] & 0x0f;
18910                      if (trace)
18911                        {
18912                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18913                                 "/** 1111 1111 0011 rdst srca srcb	mul 	%2, %1, %0 */",
18914                                 op[0], op[1], op[2]);
18915                          printf ("  rdst = 0x%x,", rdst);
18916                          printf ("  srca = 0x%x,", srca);
18917                          printf ("  srcb = 0x%x\n", srcb);
18918                        }
18919                      SYNTAX("mul 	%2, %1, %0");
18920#line 677 "rx-decode.opc"
18921                      ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18922
18923                    /*----------------------------------------------------------------------*/
18924                    /* EMUL									*/
18925
18926                    }
18927                  break;
18928              }
18929            break;
18930          case 0x31:
18931              GETBYTE ();
18932              switch (op[2] & 0x00)
18933              {
18934                case 0x00:
18935                  goto op_semantics_146;
18936                  break;
18937              }
18938            break;
18939          case 0x32:
18940              GETBYTE ();
18941              switch (op[2] & 0x00)
18942              {
18943                case 0x00:
18944                  goto op_semantics_146;
18945                  break;
18946              }
18947            break;
18948          case 0x33:
18949              GETBYTE ();
18950              switch (op[2] & 0x00)
18951              {
18952                case 0x00:
18953                  goto op_semantics_146;
18954                  break;
18955              }
18956            break;
18957          case 0x34:
18958              GETBYTE ();
18959              switch (op[2] & 0x00)
18960              {
18961                case 0x00:
18962                  goto op_semantics_146;
18963                  break;
18964              }
18965            break;
18966          case 0x35:
18967              GETBYTE ();
18968              switch (op[2] & 0x00)
18969              {
18970                case 0x00:
18971                  goto op_semantics_146;
18972                  break;
18973              }
18974            break;
18975          case 0x36:
18976              GETBYTE ();
18977              switch (op[2] & 0x00)
18978              {
18979                case 0x00:
18980                  goto op_semantics_146;
18981                  break;
18982              }
18983            break;
18984          case 0x37:
18985              GETBYTE ();
18986              switch (op[2] & 0x00)
18987              {
18988                case 0x00:
18989                  goto op_semantics_146;
18990                  break;
18991              }
18992            break;
18993          case 0x38:
18994              GETBYTE ();
18995              switch (op[2] & 0x00)
18996              {
18997                case 0x00:
18998                  goto op_semantics_146;
18999                  break;
19000              }
19001            break;
19002          case 0x39:
19003              GETBYTE ();
19004              switch (op[2] & 0x00)
19005              {
19006                case 0x00:
19007                  goto op_semantics_146;
19008                  break;
19009              }
19010            break;
19011          case 0x3a:
19012              GETBYTE ();
19013              switch (op[2] & 0x00)
19014              {
19015                case 0x00:
19016                  goto op_semantics_146;
19017                  break;
19018              }
19019            break;
19020          case 0x3b:
19021              GETBYTE ();
19022              switch (op[2] & 0x00)
19023              {
19024                case 0x00:
19025                  goto op_semantics_146;
19026                  break;
19027              }
19028            break;
19029          case 0x3c:
19030              GETBYTE ();
19031              switch (op[2] & 0x00)
19032              {
19033                case 0x00:
19034                  goto op_semantics_146;
19035                  break;
19036              }
19037            break;
19038          case 0x3d:
19039              GETBYTE ();
19040              switch (op[2] & 0x00)
19041              {
19042                case 0x00:
19043                  goto op_semantics_146;
19044                  break;
19045              }
19046            break;
19047          case 0x3e:
19048              GETBYTE ();
19049              switch (op[2] & 0x00)
19050              {
19051                case 0x00:
19052                  goto op_semantics_146;
19053                  break;
19054              }
19055            break;
19056          case 0x3f:
19057              GETBYTE ();
19058              switch (op[2] & 0x00)
19059              {
19060                case 0x00:
19061                  goto op_semantics_146;
19062                  break;
19063              }
19064            break;
19065          case 0x40:
19066              GETBYTE ();
19067              switch (op[2] & 0x00)
19068              {
19069                case 0x00:
19070                  op_semantics_147:
19071                    {
19072                      /** 1111 1111 0100 rdst srca srcb	and	%2, %1, %0 */
19073#line 447 "rx-decode.opc"
19074                      int rdst AU = op[1] & 0x0f;
19075#line 447 "rx-decode.opc"
19076                      int srca AU = (op[2] >> 4) & 0x0f;
19077#line 447 "rx-decode.opc"
19078                      int srcb AU = op[2] & 0x0f;
19079                      if (trace)
19080                        {
19081                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19082                                 "/** 1111 1111 0100 rdst srca srcb	and	%2, %1, %0 */",
19083                                 op[0], op[1], op[2]);
19084                          printf ("  rdst = 0x%x,", rdst);
19085                          printf ("  srca = 0x%x,", srca);
19086                          printf ("  srcb = 0x%x\n", srcb);
19087                        }
19088                      SYNTAX("and	%2, %1, %0");
19089#line 447 "rx-decode.opc"
19090                      ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19091
19092                    /*----------------------------------------------------------------------*/
19093                    /* OR									*/
19094
19095                    }
19096                  break;
19097              }
19098            break;
19099          case 0x41:
19100              GETBYTE ();
19101              switch (op[2] & 0x00)
19102              {
19103                case 0x00:
19104                  goto op_semantics_147;
19105                  break;
19106              }
19107            break;
19108          case 0x42:
19109              GETBYTE ();
19110              switch (op[2] & 0x00)
19111              {
19112                case 0x00:
19113                  goto op_semantics_147;
19114                  break;
19115              }
19116            break;
19117          case 0x43:
19118              GETBYTE ();
19119              switch (op[2] & 0x00)
19120              {
19121                case 0x00:
19122                  goto op_semantics_147;
19123                  break;
19124              }
19125            break;
19126          case 0x44:
19127              GETBYTE ();
19128              switch (op[2] & 0x00)
19129              {
19130                case 0x00:
19131                  goto op_semantics_147;
19132                  break;
19133              }
19134            break;
19135          case 0x45:
19136              GETBYTE ();
19137              switch (op[2] & 0x00)
19138              {
19139                case 0x00:
19140                  goto op_semantics_147;
19141                  break;
19142              }
19143            break;
19144          case 0x46:
19145              GETBYTE ();
19146              switch (op[2] & 0x00)
19147              {
19148                case 0x00:
19149                  goto op_semantics_147;
19150                  break;
19151              }
19152            break;
19153          case 0x47:
19154              GETBYTE ();
19155              switch (op[2] & 0x00)
19156              {
19157                case 0x00:
19158                  goto op_semantics_147;
19159                  break;
19160              }
19161            break;
19162          case 0x48:
19163              GETBYTE ();
19164              switch (op[2] & 0x00)
19165              {
19166                case 0x00:
19167                  goto op_semantics_147;
19168                  break;
19169              }
19170            break;
19171          case 0x49:
19172              GETBYTE ();
19173              switch (op[2] & 0x00)
19174              {
19175                case 0x00:
19176                  goto op_semantics_147;
19177                  break;
19178              }
19179            break;
19180          case 0x4a:
19181              GETBYTE ();
19182              switch (op[2] & 0x00)
19183              {
19184                case 0x00:
19185                  goto op_semantics_147;
19186                  break;
19187              }
19188            break;
19189          case 0x4b:
19190              GETBYTE ();
19191              switch (op[2] & 0x00)
19192              {
19193                case 0x00:
19194                  goto op_semantics_147;
19195                  break;
19196              }
19197            break;
19198          case 0x4c:
19199              GETBYTE ();
19200              switch (op[2] & 0x00)
19201              {
19202                case 0x00:
19203                  goto op_semantics_147;
19204                  break;
19205              }
19206            break;
19207          case 0x4d:
19208              GETBYTE ();
19209              switch (op[2] & 0x00)
19210              {
19211                case 0x00:
19212                  goto op_semantics_147;
19213                  break;
19214              }
19215            break;
19216          case 0x4e:
19217              GETBYTE ();
19218              switch (op[2] & 0x00)
19219              {
19220                case 0x00:
19221                  goto op_semantics_147;
19222                  break;
19223              }
19224            break;
19225          case 0x4f:
19226              GETBYTE ();
19227              switch (op[2] & 0x00)
19228              {
19229                case 0x00:
19230                  goto op_semantics_147;
19231                  break;
19232              }
19233            break;
19234          case 0x50:
19235              GETBYTE ();
19236              switch (op[2] & 0x00)
19237              {
19238                case 0x00:
19239                  op_semantics_148:
19240                    {
19241                      /** 1111 1111 0101 rdst srca srcb	or	%2, %1, %0 */
19242#line 465 "rx-decode.opc"
19243                      int rdst AU = op[1] & 0x0f;
19244#line 465 "rx-decode.opc"
19245                      int srca AU = (op[2] >> 4) & 0x0f;
19246#line 465 "rx-decode.opc"
19247                      int srcb AU = op[2] & 0x0f;
19248                      if (trace)
19249                        {
19250                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19251                                 "/** 1111 1111 0101 rdst srca srcb	or	%2, %1, %0 */",
19252                                 op[0], op[1], op[2]);
19253                          printf ("  rdst = 0x%x,", rdst);
19254                          printf ("  srca = 0x%x,", srca);
19255                          printf ("  srcb = 0x%x\n", srcb);
19256                        }
19257                      SYNTAX("or	%2, %1, %0");
19258#line 465 "rx-decode.opc"
19259                      ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19260
19261                    /*----------------------------------------------------------------------*/
19262                    /* XOR									*/
19263
19264                    }
19265                  break;
19266              }
19267            break;
19268          case 0x51:
19269              GETBYTE ();
19270              switch (op[2] & 0x00)
19271              {
19272                case 0x00:
19273                  goto op_semantics_148;
19274                  break;
19275              }
19276            break;
19277          case 0x52:
19278              GETBYTE ();
19279              switch (op[2] & 0x00)
19280              {
19281                case 0x00:
19282                  goto op_semantics_148;
19283                  break;
19284              }
19285            break;
19286          case 0x53:
19287              GETBYTE ();
19288              switch (op[2] & 0x00)
19289              {
19290                case 0x00:
19291                  goto op_semantics_148;
19292                  break;
19293              }
19294            break;
19295          case 0x54:
19296              GETBYTE ();
19297              switch (op[2] & 0x00)
19298              {
19299                case 0x00:
19300                  goto op_semantics_148;
19301                  break;
19302              }
19303            break;
19304          case 0x55:
19305              GETBYTE ();
19306              switch (op[2] & 0x00)
19307              {
19308                case 0x00:
19309                  goto op_semantics_148;
19310                  break;
19311              }
19312            break;
19313          case 0x56:
19314              GETBYTE ();
19315              switch (op[2] & 0x00)
19316              {
19317                case 0x00:
19318                  goto op_semantics_148;
19319                  break;
19320              }
19321            break;
19322          case 0x57:
19323              GETBYTE ();
19324              switch (op[2] & 0x00)
19325              {
19326                case 0x00:
19327                  goto op_semantics_148;
19328                  break;
19329              }
19330            break;
19331          case 0x58:
19332              GETBYTE ();
19333              switch (op[2] & 0x00)
19334              {
19335                case 0x00:
19336                  goto op_semantics_148;
19337                  break;
19338              }
19339            break;
19340          case 0x59:
19341              GETBYTE ();
19342              switch (op[2] & 0x00)
19343              {
19344                case 0x00:
19345                  goto op_semantics_148;
19346                  break;
19347              }
19348            break;
19349          case 0x5a:
19350              GETBYTE ();
19351              switch (op[2] & 0x00)
19352              {
19353                case 0x00:
19354                  goto op_semantics_148;
19355                  break;
19356              }
19357            break;
19358          case 0x5b:
19359              GETBYTE ();
19360              switch (op[2] & 0x00)
19361              {
19362                case 0x00:
19363                  goto op_semantics_148;
19364                  break;
19365              }
19366            break;
19367          case 0x5c:
19368              GETBYTE ();
19369              switch (op[2] & 0x00)
19370              {
19371                case 0x00:
19372                  goto op_semantics_148;
19373                  break;
19374              }
19375            break;
19376          case 0x5d:
19377              GETBYTE ();
19378              switch (op[2] & 0x00)
19379              {
19380                case 0x00:
19381                  goto op_semantics_148;
19382                  break;
19383              }
19384            break;
19385          case 0x5e:
19386              GETBYTE ();
19387              switch (op[2] & 0x00)
19388              {
19389                case 0x00:
19390                  goto op_semantics_148;
19391                  break;
19392              }
19393            break;
19394          case 0x5f:
19395              GETBYTE ();
19396              switch (op[2] & 0x00)
19397              {
19398                case 0x00:
19399                  goto op_semantics_148;
19400                  break;
19401              }
19402            break;
19403          case 0x60:
19404              GETBYTE ();
19405              switch (op[2] & 0x00)
19406              {
19407                case 0x00:
19408                  op_semantics_149:
19409                    {
19410                      /** 1111 1111 0110 rdst srca srcb	xor	%2, %1, %0 */
19411#line 1146 "rx-decode.opc"
19412                      int rdst AU = op[1] & 0x0f;
19413#line 1146 "rx-decode.opc"
19414                      int srca AU = (op[2] >> 4) & 0x0f;
19415#line 1146 "rx-decode.opc"
19416                      int srcb AU = op[2] & 0x0f;
19417                      if (trace)
19418                        {
19419                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19420                                 "/** 1111 1111 0110 rdst srca srcb	xor	%2, %1, %0 */",
19421                                 op[0], op[1], op[2]);
19422                          printf ("  rdst = 0x%x,", rdst);
19423                          printf ("  srca = 0x%x,", srca);
19424                          printf ("  srcb = 0x%x\n", srcb);
19425                        }
19426                      SYNTAX("xor	%2, %1, %0");
19427#line 1146 "rx-decode.opc"
19428                      ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19429
19430                    }
19431                  break;
19432              }
19433            break;
19434          case 0x61:
19435              GETBYTE ();
19436              switch (op[2] & 0x00)
19437              {
19438                case 0x00:
19439                  goto op_semantics_149;
19440                  break;
19441              }
19442            break;
19443          case 0x62:
19444              GETBYTE ();
19445              switch (op[2] & 0x00)
19446              {
19447                case 0x00:
19448                  goto op_semantics_149;
19449                  break;
19450              }
19451            break;
19452          case 0x63:
19453              GETBYTE ();
19454              switch (op[2] & 0x00)
19455              {
19456                case 0x00:
19457                  goto op_semantics_149;
19458                  break;
19459              }
19460            break;
19461          case 0x64:
19462              GETBYTE ();
19463              switch (op[2] & 0x00)
19464              {
19465                case 0x00:
19466                  goto op_semantics_149;
19467                  break;
19468              }
19469            break;
19470          case 0x65:
19471              GETBYTE ();
19472              switch (op[2] & 0x00)
19473              {
19474                case 0x00:
19475                  goto op_semantics_149;
19476                  break;
19477              }
19478            break;
19479          case 0x66:
19480              GETBYTE ();
19481              switch (op[2] & 0x00)
19482              {
19483                case 0x00:
19484                  goto op_semantics_149;
19485                  break;
19486              }
19487            break;
19488          case 0x67:
19489              GETBYTE ();
19490              switch (op[2] & 0x00)
19491              {
19492                case 0x00:
19493                  goto op_semantics_149;
19494                  break;
19495              }
19496            break;
19497          case 0x68:
19498              GETBYTE ();
19499              switch (op[2] & 0x00)
19500              {
19501                case 0x00:
19502                  goto op_semantics_149;
19503                  break;
19504              }
19505            break;
19506          case 0x69:
19507              GETBYTE ();
19508              switch (op[2] & 0x00)
19509              {
19510                case 0x00:
19511                  goto op_semantics_149;
19512                  break;
19513              }
19514            break;
19515          case 0x6a:
19516              GETBYTE ();
19517              switch (op[2] & 0x00)
19518              {
19519                case 0x00:
19520                  goto op_semantics_149;
19521                  break;
19522              }
19523            break;
19524          case 0x6b:
19525              GETBYTE ();
19526              switch (op[2] & 0x00)
19527              {
19528                case 0x00:
19529                  goto op_semantics_149;
19530                  break;
19531              }
19532            break;
19533          case 0x6c:
19534              GETBYTE ();
19535              switch (op[2] & 0x00)
19536              {
19537                case 0x00:
19538                  goto op_semantics_149;
19539                  break;
19540              }
19541            break;
19542          case 0x6d:
19543              GETBYTE ();
19544              switch (op[2] & 0x00)
19545              {
19546                case 0x00:
19547                  goto op_semantics_149;
19548                  break;
19549              }
19550            break;
19551          case 0x6e:
19552              GETBYTE ();
19553              switch (op[2] & 0x00)
19554              {
19555                case 0x00:
19556                  goto op_semantics_149;
19557                  break;
19558              }
19559            break;
19560          case 0x6f:
19561              GETBYTE ();
19562              switch (op[2] & 0x00)
19563              {
19564                case 0x00:
19565                  goto op_semantics_149;
19566                  break;
19567              }
19568            break;
19569          case 0x80:
19570              GETBYTE ();
19571              switch (op[2] & 0x00)
19572              {
19573                case 0x00:
19574                  op_semantics_150:
19575                    {
19576                      /** 1111 1111 1000 rdst srca srcb	fsub	%2, %1, %0 */
19577#line 1125 "rx-decode.opc"
19578                      int rdst AU = op[1] & 0x0f;
19579#line 1125 "rx-decode.opc"
19580                      int srca AU = (op[2] >> 4) & 0x0f;
19581#line 1125 "rx-decode.opc"
19582                      int srcb AU = op[2] & 0x0f;
19583                      if (trace)
19584                        {
19585                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19586                                 "/** 1111 1111 1000 rdst srca srcb	fsub	%2, %1, %0 */",
19587                                 op[0], op[1], op[2]);
19588                          printf ("  rdst = 0x%x,", rdst);
19589                          printf ("  srca = 0x%x,", srca);
19590                          printf ("  srcb = 0x%x\n", srcb);
19591                        }
19592                      SYNTAX("fsub	%2, %1, %0");
19593#line 1125 "rx-decode.opc"
19594                      ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19595
19596                    }
19597                  break;
19598              }
19599            break;
19600          case 0x81:
19601              GETBYTE ();
19602              switch (op[2] & 0x00)
19603              {
19604                case 0x00:
19605                  goto op_semantics_150;
19606                  break;
19607              }
19608            break;
19609          case 0x82:
19610              GETBYTE ();
19611              switch (op[2] & 0x00)
19612              {
19613                case 0x00:
19614                  goto op_semantics_150;
19615                  break;
19616              }
19617            break;
19618          case 0x83:
19619              GETBYTE ();
19620              switch (op[2] & 0x00)
19621              {
19622                case 0x00:
19623                  goto op_semantics_150;
19624                  break;
19625              }
19626            break;
19627          case 0x84:
19628              GETBYTE ();
19629              switch (op[2] & 0x00)
19630              {
19631                case 0x00:
19632                  goto op_semantics_150;
19633                  break;
19634              }
19635            break;
19636          case 0x85:
19637              GETBYTE ();
19638              switch (op[2] & 0x00)
19639              {
19640                case 0x00:
19641                  goto op_semantics_150;
19642                  break;
19643              }
19644            break;
19645          case 0x86:
19646              GETBYTE ();
19647              switch (op[2] & 0x00)
19648              {
19649                case 0x00:
19650                  goto op_semantics_150;
19651                  break;
19652              }
19653            break;
19654          case 0x87:
19655              GETBYTE ();
19656              switch (op[2] & 0x00)
19657              {
19658                case 0x00:
19659                  goto op_semantics_150;
19660                  break;
19661              }
19662            break;
19663          case 0x88:
19664              GETBYTE ();
19665              switch (op[2] & 0x00)
19666              {
19667                case 0x00:
19668                  goto op_semantics_150;
19669                  break;
19670              }
19671            break;
19672          case 0x89:
19673              GETBYTE ();
19674              switch (op[2] & 0x00)
19675              {
19676                case 0x00:
19677                  goto op_semantics_150;
19678                  break;
19679              }
19680            break;
19681          case 0x8a:
19682              GETBYTE ();
19683              switch (op[2] & 0x00)
19684              {
19685                case 0x00:
19686                  goto op_semantics_150;
19687                  break;
19688              }
19689            break;
19690          case 0x8b:
19691              GETBYTE ();
19692              switch (op[2] & 0x00)
19693              {
19694                case 0x00:
19695                  goto op_semantics_150;
19696                  break;
19697              }
19698            break;
19699          case 0x8c:
19700              GETBYTE ();
19701              switch (op[2] & 0x00)
19702              {
19703                case 0x00:
19704                  goto op_semantics_150;
19705                  break;
19706              }
19707            break;
19708          case 0x8d:
19709              GETBYTE ();
19710              switch (op[2] & 0x00)
19711              {
19712                case 0x00:
19713                  goto op_semantics_150;
19714                  break;
19715              }
19716            break;
19717          case 0x8e:
19718              GETBYTE ();
19719              switch (op[2] & 0x00)
19720              {
19721                case 0x00:
19722                  goto op_semantics_150;
19723                  break;
19724              }
19725            break;
19726          case 0x8f:
19727              GETBYTE ();
19728              switch (op[2] & 0x00)
19729              {
19730                case 0x00:
19731                  goto op_semantics_150;
19732                  break;
19733              }
19734            break;
19735          case 0xa0:
19736              GETBYTE ();
19737              switch (op[2] & 0x00)
19738              {
19739                case 0x00:
19740                  op_semantics_151:
19741                    {
19742                      /** 1111 1111 1010 rdst srca srcb	fadd	%2, %1, %0 */
19743#line 1122 "rx-decode.opc"
19744                      int rdst AU = op[1] & 0x0f;
19745#line 1122 "rx-decode.opc"
19746                      int srca AU = (op[2] >> 4) & 0x0f;
19747#line 1122 "rx-decode.opc"
19748                      int srcb AU = op[2] & 0x0f;
19749                      if (trace)
19750                        {
19751                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19752                                 "/** 1111 1111 1010 rdst srca srcb	fadd	%2, %1, %0 */",
19753                                 op[0], op[1], op[2]);
19754                          printf ("  rdst = 0x%x,", rdst);
19755                          printf ("  srca = 0x%x,", srca);
19756                          printf ("  srcb = 0x%x\n", srcb);
19757                        }
19758                      SYNTAX("fadd	%2, %1, %0");
19759#line 1122 "rx-decode.opc"
19760                      ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19761
19762                    }
19763                  break;
19764              }
19765            break;
19766          case 0xa1:
19767              GETBYTE ();
19768              switch (op[2] & 0x00)
19769              {
19770                case 0x00:
19771                  goto op_semantics_151;
19772                  break;
19773              }
19774            break;
19775          case 0xa2:
19776              GETBYTE ();
19777              switch (op[2] & 0x00)
19778              {
19779                case 0x00:
19780                  goto op_semantics_151;
19781                  break;
19782              }
19783            break;
19784          case 0xa3:
19785              GETBYTE ();
19786              switch (op[2] & 0x00)
19787              {
19788                case 0x00:
19789                  goto op_semantics_151;
19790                  break;
19791              }
19792            break;
19793          case 0xa4:
19794              GETBYTE ();
19795              switch (op[2] & 0x00)
19796              {
19797                case 0x00:
19798                  goto op_semantics_151;
19799                  break;
19800              }
19801            break;
19802          case 0xa5:
19803              GETBYTE ();
19804              switch (op[2] & 0x00)
19805              {
19806                case 0x00:
19807                  goto op_semantics_151;
19808                  break;
19809              }
19810            break;
19811          case 0xa6:
19812              GETBYTE ();
19813              switch (op[2] & 0x00)
19814              {
19815                case 0x00:
19816                  goto op_semantics_151;
19817                  break;
19818              }
19819            break;
19820          case 0xa7:
19821              GETBYTE ();
19822              switch (op[2] & 0x00)
19823              {
19824                case 0x00:
19825                  goto op_semantics_151;
19826                  break;
19827              }
19828            break;
19829          case 0xa8:
19830              GETBYTE ();
19831              switch (op[2] & 0x00)
19832              {
19833                case 0x00:
19834                  goto op_semantics_151;
19835                  break;
19836              }
19837            break;
19838          case 0xa9:
19839              GETBYTE ();
19840              switch (op[2] & 0x00)
19841              {
19842                case 0x00:
19843                  goto op_semantics_151;
19844                  break;
19845              }
19846            break;
19847          case 0xaa:
19848              GETBYTE ();
19849              switch (op[2] & 0x00)
19850              {
19851                case 0x00:
19852                  goto op_semantics_151;
19853                  break;
19854              }
19855            break;
19856          case 0xab:
19857              GETBYTE ();
19858              switch (op[2] & 0x00)
19859              {
19860                case 0x00:
19861                  goto op_semantics_151;
19862                  break;
19863              }
19864            break;
19865          case 0xac:
19866              GETBYTE ();
19867              switch (op[2] & 0x00)
19868              {
19869                case 0x00:
19870                  goto op_semantics_151;
19871                  break;
19872              }
19873            break;
19874          case 0xad:
19875              GETBYTE ();
19876              switch (op[2] & 0x00)
19877              {
19878                case 0x00:
19879                  goto op_semantics_151;
19880                  break;
19881              }
19882            break;
19883          case 0xae:
19884              GETBYTE ();
19885              switch (op[2] & 0x00)
19886              {
19887                case 0x00:
19888                  goto op_semantics_151;
19889                  break;
19890              }
19891            break;
19892          case 0xaf:
19893              GETBYTE ();
19894              switch (op[2] & 0x00)
19895              {
19896                case 0x00:
19897                  goto op_semantics_151;
19898                  break;
19899              }
19900            break;
19901          case 0xb0:
19902              GETBYTE ();
19903              switch (op[2] & 0x00)
19904              {
19905                case 0x00:
19906                  op_semantics_152:
19907                    {
19908                      /** 1111 1111 1011 rdst srca srcb	fmul	%2, %1, %0 */
19909#line 1128 "rx-decode.opc"
19910                      int rdst AU = op[1] & 0x0f;
19911#line 1128 "rx-decode.opc"
19912                      int srca AU = (op[2] >> 4) & 0x0f;
19913#line 1128 "rx-decode.opc"
19914                      int srcb AU = op[2] & 0x0f;
19915                      if (trace)
19916                        {
19917                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19918                                 "/** 1111 1111 1011 rdst srca srcb	fmul	%2, %1, %0 */",
19919                                 op[0], op[1], op[2]);
19920                          printf ("  rdst = 0x%x,", rdst);
19921                          printf ("  srca = 0x%x,", srca);
19922                          printf ("  srcb = 0x%x\n", srcb);
19923                        }
19924                      SYNTAX("fmul	%2, %1, %0");
19925#line 1128 "rx-decode.opc"
19926                      ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19927
19928                    }
19929                  break;
19930              }
19931            break;
19932          case 0xb1:
19933              GETBYTE ();
19934              switch (op[2] & 0x00)
19935              {
19936                case 0x00:
19937                  goto op_semantics_152;
19938                  break;
19939              }
19940            break;
19941          case 0xb2:
19942              GETBYTE ();
19943              switch (op[2] & 0x00)
19944              {
19945                case 0x00:
19946                  goto op_semantics_152;
19947                  break;
19948              }
19949            break;
19950          case 0xb3:
19951              GETBYTE ();
19952              switch (op[2] & 0x00)
19953              {
19954                case 0x00:
19955                  goto op_semantics_152;
19956                  break;
19957              }
19958            break;
19959          case 0xb4:
19960              GETBYTE ();
19961              switch (op[2] & 0x00)
19962              {
19963                case 0x00:
19964                  goto op_semantics_152;
19965                  break;
19966              }
19967            break;
19968          case 0xb5:
19969              GETBYTE ();
19970              switch (op[2] & 0x00)
19971              {
19972                case 0x00:
19973                  goto op_semantics_152;
19974                  break;
19975              }
19976            break;
19977          case 0xb6:
19978              GETBYTE ();
19979              switch (op[2] & 0x00)
19980              {
19981                case 0x00:
19982                  goto op_semantics_152;
19983                  break;
19984              }
19985            break;
19986          case 0xb7:
19987              GETBYTE ();
19988              switch (op[2] & 0x00)
19989              {
19990                case 0x00:
19991                  goto op_semantics_152;
19992                  break;
19993              }
19994            break;
19995          case 0xb8:
19996              GETBYTE ();
19997              switch (op[2] & 0x00)
19998              {
19999                case 0x00:
20000                  goto op_semantics_152;
20001                  break;
20002              }
20003            break;
20004          case 0xb9:
20005              GETBYTE ();
20006              switch (op[2] & 0x00)
20007              {
20008                case 0x00:
20009                  goto op_semantics_152;
20010                  break;
20011              }
20012            break;
20013          case 0xba:
20014              GETBYTE ();
20015              switch (op[2] & 0x00)
20016              {
20017                case 0x00:
20018                  goto op_semantics_152;
20019                  break;
20020              }
20021            break;
20022          case 0xbb:
20023              GETBYTE ();
20024              switch (op[2] & 0x00)
20025              {
20026                case 0x00:
20027                  goto op_semantics_152;
20028                  break;
20029              }
20030            break;
20031          case 0xbc:
20032              GETBYTE ();
20033              switch (op[2] & 0x00)
20034              {
20035                case 0x00:
20036                  goto op_semantics_152;
20037                  break;
20038              }
20039            break;
20040          case 0xbd:
20041              GETBYTE ();
20042              switch (op[2] & 0x00)
20043              {
20044                case 0x00:
20045                  goto op_semantics_152;
20046                  break;
20047              }
20048            break;
20049          case 0xbe:
20050              GETBYTE ();
20051              switch (op[2] & 0x00)
20052              {
20053                case 0x00:
20054                  goto op_semantics_152;
20055                  break;
20056              }
20057            break;
20058          case 0xbf:
20059              GETBYTE ();
20060              switch (op[2] & 0x00)
20061              {
20062                case 0x00:
20063                  goto op_semantics_152;
20064                  break;
20065              }
20066            break;
20067          default: UNSUPPORTED(); break;
20068        }
20069      break;
20070    default: UNSUPPORTED(); break;
20071  }
20072#line 1280 "rx-decode.opc"
20073
20074  return rx->n_bytes;
20075}
20076