12116Sjkh/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
22116Sjkh#line 1 "rx-decode.opc"
32116Sjkh/* -*- c -*- */
42116Sjkh/* Copyright (C) 2012-2020 Free Software Foundation, Inc.
52116Sjkh   Contributed by Red Hat.
62116Sjkh   Written by DJ Delorie.
72116Sjkh
88870Srgrimes   This file is part of the GNU opcodes library.
92116Sjkh
102116Sjkh   This library is free software; you can redistribute it and/or modify
112116Sjkh   it under the terms of the GNU General Public License as published by
122116Sjkh   the Free Software Foundation; either version 3, or (at your option)
13176451Sdas   any later version.
14176451Sdas
152116Sjkh   It is distributed in the hope that it will be useful, but WITHOUT
162116Sjkh   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
172116Sjkh   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
182116Sjkh   License for more details.
192116Sjkh
202116Sjkh   You should have received a copy of the GNU General Public License
212116Sjkh   along with this program; if not, write to the Free Software
222116Sjkh   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
232116Sjkh   MA 02110-1301, USA.  */
242116Sjkh
252116Sjkh#include "sysdep.h"
26160122Sbde#include <stdio.h>
272116Sjkh#include <stdlib.h>
28160122Sbde#include <string.h>
292116Sjkh#include "ansidecl.h"
302116Sjkh#include "opcode/rx.h"
31160122Sbde#include "libiberty.h"
322116Sjkh
33160122Sbde#define RX_OPCODE_BIG_ENDIAN 0
342116Sjkh
352116Sjkhtypedef struct
362116Sjkh{
372116Sjkh  RX_Opcode_Decoded * rx;
382116Sjkh  int (* getbyte)(void *);
392116Sjkh  void * ptr;
40260067Skargl  unsigned char * op;
41260067Skargl} LocalData;
422116Sjkh
432116Sjkhstatic int trace = 0;
442116Sjkh
45270847Skargl#define BSIZE 0
46270845Skargl#define WSIZE 1
472116Sjkh#define LSIZE 2
4897413Salfred#define DSIZE 3
4997413Salfred
502116Sjkh/* These are for when the upper bits are "don't care" or "undefined".  */
512116Sjkhstatic int bwl[4] =
522116Sjkh{
532116Sjkh  RX_Byte,
542116Sjkh  RX_Word,
552116Sjkh  RX_Long,
562116Sjkh  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
572116Sjkh};
588870Srgrimes
592116Sjkhstatic int sbwl[4] =
602116Sjkh{
612116Sjkh  RX_SByte,
622116Sjkh  RX_SWord,
632116Sjkh  RX_Long,
642116Sjkh  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
65160122Sbde};
66160122Sbde
67160122Sbdestatic int ubw[4] =
682116Sjkh{
692116Sjkh  RX_UByte,
702116Sjkh  RX_UWord,
712116Sjkh  RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
722116Sjkh  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
732116Sjkh};
742116Sjkh
75160122Sbdestatic int memex[4] =
762116Sjkh{
77160122Sbde  RX_SByte,
782116Sjkh  RX_SWord,
792116Sjkh  RX_Long,
802116Sjkh  RX_UWord
81260067Skargl};
82260067Skargl
83260067Skarglstatic int _ld[2] =
84260067Skargl{
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 rdst	mvtacgu	%0, %1 */
12480#line 1110 "rx-decode.opc"
12481                      int a AU = (op[2] >> 7) & 0x01;
12482#line 1110 "rx-decode.opc"
12483                      int rdst 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 rdst	mvtacgu	%0, %1 */",
12488                                 op[0], op[1], op[2]);
12489                          printf ("  a = 0x%x,", a);
12490                          printf ("  rdst = 0x%x\n", rdst);
12491                        }
12492                      SYNTAX("mvtacgu	%0, %1");
12493#line 1110 "rx-decode.opc"
12494                      ID(mvtacgu); DR(a+32); SR(rdst); 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