Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/opcodes/rx-decode.c
Line
Count
Source (jump to first uncovered line)
1
/* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
2
#line 1 "rx-decode.opc"
3
/* -*- c -*- */
4
/* Copyright (C) 2012-2024 Free Software Foundation, Inc.
5
   Contributed by Red Hat.
6
   Written by DJ Delorie.
7
8
   This file is part of the GNU opcodes library.
9
10
   This library is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3, or (at your option)
13
   any later version.
14
15
   It is distributed in the hope that it will be useful, but WITHOUT
16
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18
   License for more details.
19
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23
   MA 02110-1301, USA.  */
24
25
#include "sysdep.h"
26
#include <stdio.h>
27
#include <stdlib.h>
28
#include <string.h>
29
#include "ansidecl.h"
30
#include "opcode/rx.h"
31
#include "libiberty.h"
32
33
#define RX_OPCODE_BIG_ENDIAN 0
34
35
typedef struct
36
{
37
  RX_Opcode_Decoded * rx;
38
  int (* getbyte)(void *);
39
  void * ptr;
40
  unsigned char * op;
41
} LocalData;
42
43
static int trace = 0;
44
45
#define BSIZE 0
46
#define WSIZE 1
47
#define LSIZE 2
48
#define DSIZE 3
49
50
/* These are for when the upper bits are "don't care" or "undefined".  */
51
static int bwl[4] =
52
{
53
  RX_Byte,
54
  RX_Word,
55
  RX_Long,
56
  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
57
};
58
59
static int sbwl[4] =
60
{
61
  RX_SByte,
62
  RX_SWord,
63
  RX_Long,
64
  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
65
};
66
67
static int ubw[4] =
68
{
69
  RX_UByte,
70
  RX_UWord,
71
  RX_Bad_Size,/* Bogus instructions can have a size field set to 2.  */
72
  RX_Bad_Size /* Bogus instructions can have a size field set to 3.  */
73
};
74
75
static int memex[4] =
76
{
77
  RX_SByte,
78
  RX_SWord,
79
  RX_Long,
80
  RX_UWord
81
};
82
83
static int _ld[2] =
84
{
85
  RX_Long,
86
  RX_Double
87
};
88
89
13.7M
#define ID(x) rx->id = RXO_##x
90
12.4M
#define OP(n,t,r,a) (rx->op[n].type = t, \
91
12.4M
         rx->op[n].reg = r,      \
92
12.4M
         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.  */
97
static int SCALE[] = { 1, 2, 4, 0 };
98
/* This is for the prefix size enum.  */
99
static 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
1.70M
#define GET_PSCALE(_indx) ((unsigned)(_indx) < ARRAY_SIZE (PSCALE) ? PSCALE[(_indx)] : 0)
103
104
static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0,
105
           16, 17, 0, 0, 0, 0, 0, 0 };
106
107
static 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
2.10M
#define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
120
3.13M
#define DR(r)       OP (0, RX_Operand_Register,  r, 0)
121
#define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
122
767k
#define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
123
1.48M
#define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
124
3.93k
#define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
125
2.26k
#define DCR(r)      OP (0, RX_Operand_DoubleCReg, r, 0)
126
15.1k
#define DDR(r)      OP (0, RX_Operand_DoubleReg,  r, 0)
127
2.03k
#define DDRH(r)     OP (0, RX_Operand_DoubleRegH,  r, 0)
128
884
#define DDRL(r)     OP (0, RX_Operand_DoubleRegL,  r, 0)
129
2.55k
#define DCND(r)     OP (0, RX_Operand_DoubleCond, r, 0)
130
131
1.09M
#define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
132
1.81M
#define SR(r)       OP (1, RX_Operand_Register,  r, 0)
133
34.2k
#define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
134
#define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
135
957k
#define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
136
1.42M
#define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
137
530k
#define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
138
32.7k
#define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
139
1.30M
#define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
140
1.76k
#define SCR(r)      OP (1, RX_Operand_DoubleCReg, r, 0)
141
15.6k
#define SDR(r)      OP (1, RX_Operand_DoubleReg,  r, 0)
142
525
#define SDRH(r)      OP (1, RX_Operand_DoubleRegH,  r, 0)
143
696
#define SDRL(r)      OP (1, RX_Operand_DoubleRegL,  r, 0)
144
145
512k
#define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
146
549k
#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
323k
#define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
151
32.0k
#define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
152
52.2k
#define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
153
10.7k
#define S2DR(r)     OP (2, RX_Operand_DoubleReg,  r, 0)
154
1.06k
#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
15.8M
#define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
159
2.64M
#define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
160
569k
#define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
161
854k
#define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
162
2.03k
#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
27.9M
#define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
168
169
13.7M
#define SYNTAX(x) rx->syntax = x
170
171
#define UNSUPPORTED() \
172
1.57M
  rx->syntax = "*unknown*"
173
174
#define IMM(sf)   immediate (sf, 0, ld)
175
6.89k
#define IMMex(sf) immediate (sf, 1, ld)
176
177
static int
178
immediate (int sfield, int ex, LocalData * ld)
179
1.52M
{
180
1.52M
  unsigned long i = 0, j;
181
182
1.52M
  switch (sfield)
183
1.52M
    {
184
2.72M
#define B ((unsigned long) GETBYTE())
185
101k
    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
101k
      i = B;
196
101k
      i |= B << 8;
197
101k
      i |= B << 16;
198
101k
      j = B;
199
101k
      if (ex && (j & 0x80))
200
23.7k
  j -= 0x100;
201
101k
      i |= j << 24;
202
101k
#endif
203
101k
      break;
204
299k
    case 3:
205
#if RX_OPCODE_BIG_ENDIAN
206
      i  = B << 16;
207
      i |= B << 8;
208
      i |= B;
209
#else
210
299k
      i  = B;
211
299k
      i |= B << 8;
212
299k
      i |= B << 16;
213
299k
#endif
214
299k
      if (ex && (i & 0x800000))
215
67.0k
  i -= 0x1000000;
216
299k
      break;
217
298k
    case 2:
218
#if RX_OPCODE_BIG_ENDIAN
219
      i |= B << 8;
220
      i |= B;
221
#else
222
298k
      i |= B;
223
298k
      i |= B << 8;
224
298k
#endif
225
298k
      if (ex && (i & 0x8000))
226
92.8k
  i -= 0x10000;
227
298k
      break;
228
825k
    case 1:
229
825k
      i |= B;
230
825k
      if (ex && (i & 0x80))
231
164k
  i -= 0x100;
232
825k
      break;
233
0
    default:
234
0
      abort();
235
1.52M
    }
236
1.52M
  return i;
237
1.52M
}
238
239
static void
240
rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
241
3.83M
{
242
3.83M
  int disp;
243
244
3.83M
  ld->rx->op[n].reg = reg;
245
3.83M
  switch (type)
246
3.83M
    {
247
932k
    case 3:
248
932k
      ld->rx->op[n].type = RX_Operand_Register;
249
932k
      break;
250
1.19M
    case 0:
251
1.19M
      ld->rx->op[n].type = RX_Operand_Zero_Indirect;
252
1.19M
      ld->rx->op[n].addend = 0;
253
1.19M
      break;
254
892k
    case 1:
255
892k
      ld->rx->op[n].type = RX_Operand_Indirect;
256
892k
      disp = GETBYTE ();
257
892k
      ld->rx->op[n].addend = disp * GET_PSCALE (size);
258
892k
      break;
259
812k
    case 2:
260
812k
      ld->rx->op[n].type = RX_Operand_Indirect;
261
812k
      disp = GETBYTE ();
262
#if RX_OPCODE_BIG_ENDIAN
263
      disp = disp * 256 + GETBYTE ();
264
#else
265
812k
      disp = disp + GETBYTE () * 256;
266
812k
#endif
267
812k
      ld->rx->op[n].addend = disp * GET_PSCALE (size);
268
812k
      break;
269
0
    default:
270
0
      abort ();
271
3.83M
    }
272
3.83M
}
273
274
1.15M
#define xO 8
275
1.76M
#define xS 4
276
1.87M
#define xZ 2
277
1.41M
#define xC 1
278
279
#define F_____
280
116k
#define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
281
453k
#define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
282
110k
#define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
283
49.7k
#define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
284
4.04k
#define F_O___ rx->flags_0 = rx->flags_s = xO;
285
133
#define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
286
4.20k
#define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
287
1.09M
#define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
288
289
int
290
rx_decode_opcode (unsigned long pc AU,
291
      RX_Opcode_Decoded * rx,
292
      int (* getbyte)(void *),
293
      void * ptr)
294
15.3M
{
295
15.3M
  LocalData lds, * ld = &lds;
296
15.3M
  unsigned char op[20] = {0};
297
298
15.3M
  lds.rx = rx;
299
15.3M
  lds.getbyte = getbyte;
300
15.3M
  lds.ptr = ptr;
301
15.3M
  lds.op = op;
302
303
15.3M
  memset (rx, 0, sizeof (*rx));
304
15.3M
  BWL(LSIZE);
305
306
307
/*----------------------------------------------------------------------*/
308
/* MOV                  */
309
310
15.3M
  GETBYTE ();
311
15.3M
  switch (op[0] & 0xff)
312
15.3M
  {
313
5.06M
    case 0x00:
314
5.06M
        {
315
          /** 0000 0000     brk */
316
5.06M
          if (trace)
317
0
            {
318
0
              printf ("\033[33m%s\033[0m  %02x\n",
319
0
                     "/** 0000 0000     brk */",
320
0
                     op[0]);
321
0
            }
322
5.06M
          SYNTAX("brk");
323
5.06M
#line 1050 "rx-decode.opc"
324
5.06M
          ID(brk);
325
326
5.06M
        }
327
5.06M
      break;
328
282k
    case 0x01:
329
282k
        {
330
          /** 0000 0001     dbt */
331
282k
          if (trace)
332
0
            {
333
0
              printf ("\033[33m%s\033[0m  %02x\n",
334
0
                     "/** 0000 0001     dbt */",
335
0
                     op[0]);
336
0
            }
337
282k
          SYNTAX("dbt");
338
282k
#line 1053 "rx-decode.opc"
339
282k
          ID(dbt);
340
341
282k
        }
342
282k
      break;
343
224k
    case 0x02:
344
224k
        {
345
          /** 0000 0010     rts */
346
224k
          if (trace)
347
0
            {
348
0
              printf ("\033[33m%s\033[0m  %02x\n",
349
0
                     "/** 0000 0010     rts */",
350
0
                     op[0]);
351
0
            }
352
224k
          SYNTAX("rts");
353
224k
#line 831 "rx-decode.opc"
354
224k
          ID(rts);
355
356
        /*----------------------------------------------------------------------*/
357
        /* NOP                */
358
359
224k
        }
360
224k
      break;
361
107k
    case 0x03:
362
107k
        {
363
          /** 0000 0011     nop */
364
107k
          if (trace)
365
0
            {
366
0
              printf ("\033[33m%s\033[0m  %02x\n",
367
0
                     "/** 0000 0011     nop */",
368
0
                     op[0]);
369
0
            }
370
107k
          SYNTAX("nop");
371
107k
#line 837 "rx-decode.opc"
372
107k
          ID(nop);
373
374
        /*----------------------------------------------------------------------*/
375
        /* STRING FUNCTIONS             */
376
377
107k
        }
378
107k
      break;
379
135k
    case 0x04:
380
135k
        {
381
          /** 0000 0100     bra.a %a0 */
382
135k
          if (trace)
383
0
            {
384
0
              printf ("\033[33m%s\033[0m  %02x\n",
385
0
                     "/** 0000 0100     bra.a %a0 */",
386
0
                     op[0]);
387
0
            }
388
135k
          SYNTAX("bra.a %a0");
389
135k
#line 809 "rx-decode.opc"
390
135k
          ID(branch); DC(pc + IMMex(3));
391
392
135k
        }
393
135k
      break;
394
62.4k
    case 0x05:
395
62.4k
        {
396
          /** 0000 0101     bsr.a %a0 */
397
62.4k
          if (trace)
398
0
            {
399
0
              printf ("\033[33m%s\033[0m  %02x\n",
400
0
                     "/** 0000 0101     bsr.a %a0 */",
401
0
                     op[0]);
402
0
            }
403
62.4k
          SYNTAX("bsr.a %a0");
404
62.4k
#line 825 "rx-decode.opc"
405
62.4k
          ID(jsr); DC(pc + IMMex(3));
406
407
62.4k
        }
408
62.4k
      break;
409
91.8k
    case 0x06:
410
91.8k
        GETBYTE ();
411
91.8k
        switch (op[1] & 0xff)
412
91.8k
        {
413
18.4k
          case 0x00:
414
18.4k
              GETBYTE ();
415
18.4k
              switch (op[2] & 0x00)
416
18.4k
              {
417
18.4k
                case 0x00:
418
24.4k
                  op_semantics_1:
419
24.4k
                    {
420
                      /** 0000 0110 mx00 00ss rsrc rdst     sub %2%S2, %1 */
421
24.4k
#line 567 "rx-decode.opc"
422
24.4k
                      int mx AU = (op[1] >> 6) & 0x03;
423
24.4k
#line 567 "rx-decode.opc"
424
24.4k
                      int ss AU = op[1] & 0x03;
425
24.4k
#line 567 "rx-decode.opc"
426
24.4k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
427
24.4k
#line 567 "rx-decode.opc"
428
24.4k
                      int rdst AU = op[2] & 0x0f;
429
24.4k
                      if (trace)
430
0
                        {
431
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
432
0
                                 "/** 0000 0110 mx00 00ss rsrc rdst     sub %2%S2, %1 */",
433
0
                                 op[0], op[1], op[2]);
434
0
                          printf ("  mx = 0x%x,", mx);
435
0
                          printf ("  ss = 0x%x,", ss);
436
0
                          printf ("  rsrc = 0x%x,", rsrc);
437
0
                          printf ("  rdst = 0x%x\n", rdst);
438
0
                        }
439
24.4k
                      SYNTAX("sub %2%S2, %1");
440
24.4k
#line 567 "rx-decode.opc"
441
24.4k
                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
442
443
24.4k
                    }
444
24.4k
                  break;
445
18.4k
              }
446
24.4k
            break;
447
24.4k
          case 0x01:
448
686
              GETBYTE ();
449
686
              switch (op[2] & 0x00)
450
686
              {
451
686
                case 0x00:
452
686
                  goto op_semantics_1;
453
0
                  break;
454
686
              }
455
0
            break;
456
236
          case 0x02:
457
236
              GETBYTE ();
458
236
              switch (op[2] & 0x00)
459
236
              {
460
236
                case 0x00:
461
236
                  goto op_semantics_1;
462
0
                  break;
463
236
              }
464
0
            break;
465
2.25k
          case 0x03:
466
2.25k
              GETBYTE ();
467
2.25k
              switch (op[2] & 0x00)
468
2.25k
              {
469
2.25k
                case 0x00:
470
2.25k
                  goto op_semantics_1;
471
0
                  break;
472
2.25k
              }
473
0
            break;
474
228
          case 0x04:
475
228
              GETBYTE ();
476
228
              switch (op[2] & 0x00)
477
228
              {
478
228
                case 0x00:
479
7.62k
                  op_semantics_2:
480
7.62k
                    {
481
                      /** 0000 0110 mx00 01ss rsrc rdst   cmp %2%S2, %1 */
482
7.62k
#line 555 "rx-decode.opc"
483
7.62k
                      int mx AU = (op[1] >> 6) & 0x03;
484
7.62k
#line 555 "rx-decode.opc"
485
7.62k
                      int ss AU = op[1] & 0x03;
486
7.62k
#line 555 "rx-decode.opc"
487
7.62k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
488
7.62k
#line 555 "rx-decode.opc"
489
7.62k
                      int rdst AU = op[2] & 0x0f;
490
7.62k
                      if (trace)
491
0
                        {
492
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
493
0
                                 "/** 0000 0110 mx00 01ss rsrc rdst   cmp %2%S2, %1 */",
494
0
                                 op[0], op[1], op[2]);
495
0
                          printf ("  mx = 0x%x,", mx);
496
0
                          printf ("  ss = 0x%x,", ss);
497
0
                          printf ("  rsrc = 0x%x,", rsrc);
498
0
                          printf ("  rdst = 0x%x\n", rdst);
499
0
                        }
500
7.62k
                      SYNTAX("cmp %2%S2, %1");
501
7.62k
#line 555 "rx-decode.opc"
502
7.62k
                      ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
503
504
                    /*----------------------------------------------------------------------*/
505
                    /* SUB                  */
506
507
7.62k
                    }
508
7.62k
                  break;
509
228
              }
510
7.62k
            break;
511
7.62k
          case 0x05:
512
220
              GETBYTE ();
513
220
              switch (op[2] & 0x00)
514
220
              {
515
220
                case 0x00:
516
220
                  goto op_semantics_2;
517
0
                  break;
518
220
              }
519
0
            break;
520
4.75k
          case 0x06:
521
4.75k
              GETBYTE ();
522
4.75k
              switch (op[2] & 0x00)
523
4.75k
              {
524
4.75k
                case 0x00:
525
4.75k
                  goto op_semantics_2;
526
0
                  break;
527
4.75k
              }
528
0
            break;
529
64
          case 0x07:
530
64
              GETBYTE ();
531
64
              switch (op[2] & 0x00)
532
64
              {
533
64
                case 0x00:
534
64
                  goto op_semantics_2;
535
0
                  break;
536
64
              }
537
0
            break;
538
1.75k
          case 0x08:
539
1.75k
              GETBYTE ();
540
1.75k
              switch (op[2] & 0x00)
541
1.75k
              {
542
1.75k
                case 0x00:
543
4.13k
                  op_semantics_3:
544
4.13k
                    {
545
                      /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
546
4.13k
#line 531 "rx-decode.opc"
547
4.13k
                      int mx AU = (op[1] >> 6) & 0x03;
548
4.13k
#line 531 "rx-decode.opc"
549
4.13k
                      int ss AU = op[1] & 0x03;
550
4.13k
#line 531 "rx-decode.opc"
551
4.13k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
552
4.13k
#line 531 "rx-decode.opc"
553
4.13k
                      int rdst AU = op[2] & 0x0f;
554
4.13k
                      if (trace)
555
0
                        {
556
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
557
0
                                 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
558
0
                                 op[0], op[1], op[2]);
559
0
                          printf ("  mx = 0x%x,", mx);
560
0
                          printf ("  ss = 0x%x,", ss);
561
0
                          printf ("  rsrc = 0x%x,", rsrc);
562
0
                          printf ("  rdst = 0x%x\n", rdst);
563
0
                        }
564
4.13k
                      SYNTAX("add %1%S1, %0");
565
4.13k
#line 531 "rx-decode.opc"
566
4.13k
                      ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
567
568
4.13k
                    }
569
4.13k
                  break;
570
1.75k
              }
571
4.13k
            break;
572
4.13k
          case 0x09:
573
291
              GETBYTE ();
574
291
              switch (op[2] & 0x00)
575
291
              {
576
291
                case 0x00:
577
291
                  goto op_semantics_3;
578
0
                  break;
579
291
              }
580
0
            break;
581
318
          case 0x0a:
582
318
              GETBYTE ();
583
318
              switch (op[2] & 0x00)
584
318
              {
585
318
                case 0x00:
586
318
                  goto op_semantics_3;
587
0
                  break;
588
318
              }
589
0
            break;
590
49
          case 0x0b:
591
49
              GETBYTE ();
592
49
              switch (op[2] & 0x00)
593
49
              {
594
49
                case 0x00:
595
49
                  goto op_semantics_3;
596
0
                  break;
597
49
              }
598
0
            break;
599
60
          case 0x0c:
600
60
              GETBYTE ();
601
60
              switch (op[2] & 0x00)
602
60
              {
603
60
                case 0x00:
604
5.92k
                  op_semantics_4:
605
5.92k
                    {
606
                      /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
607
5.92k
#line 674 "rx-decode.opc"
608
5.92k
                      int mx AU = (op[1] >> 6) & 0x03;
609
5.92k
#line 674 "rx-decode.opc"
610
5.92k
                      int ss AU = op[1] & 0x03;
611
5.92k
#line 674 "rx-decode.opc"
612
5.92k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
613
5.92k
#line 674 "rx-decode.opc"
614
5.92k
                      int rdst AU = op[2] & 0x0f;
615
5.92k
                      if (trace)
616
0
                        {
617
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
618
0
                                 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
619
0
                                 op[0], op[1], op[2]);
620
0
                          printf ("  mx = 0x%x,", mx);
621
0
                          printf ("  ss = 0x%x,", ss);
622
0
                          printf ("  rsrc = 0x%x,", rsrc);
623
0
                          printf ("  rdst = 0x%x\n", rdst);
624
0
                        }
625
5.92k
                      SYNTAX("mul %1%S1, %0");
626
5.92k
#line 674 "rx-decode.opc"
627
5.92k
                      ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
628
629
5.92k
                    }
630
5.92k
                  break;
631
60
              }
632
5.92k
            break;
633
5.92k
          case 0x0d:
634
190
              GETBYTE ();
635
190
              switch (op[2] & 0x00)
636
190
              {
637
190
                case 0x00:
638
190
                  goto op_semantics_4;
639
0
                  break;
640
190
              }
641
0
            break;
642
190
          case 0x0e:
643
190
              GETBYTE ();
644
190
              switch (op[2] & 0x00)
645
190
              {
646
190
                case 0x00:
647
190
                  goto op_semantics_4;
648
0
                  break;
649
190
              }
650
0
            break;
651
331
          case 0x0f:
652
331
              GETBYTE ();
653
331
              switch (op[2] & 0x00)
654
331
              {
655
331
                case 0x00:
656
331
                  goto op_semantics_4;
657
0
                  break;
658
331
              }
659
0
            break;
660
258
          case 0x10:
661
258
              GETBYTE ();
662
258
              switch (op[2] & 0x00)
663
258
              {
664
258
                case 0x00:
665
3.76k
                  op_semantics_5:
666
3.76k
                    {
667
                      /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
668
3.76k
#line 444 "rx-decode.opc"
669
3.76k
                      int mx AU = (op[1] >> 6) & 0x03;
670
3.76k
#line 444 "rx-decode.opc"
671
3.76k
                      int ss AU = op[1] & 0x03;
672
3.76k
#line 444 "rx-decode.opc"
673
3.76k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
674
3.76k
#line 444 "rx-decode.opc"
675
3.76k
                      int rdst AU = op[2] & 0x0f;
676
3.76k
                      if (trace)
677
0
                        {
678
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
679
0
                                 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
680
0
                                 op[0], op[1], op[2]);
681
0
                          printf ("  mx = 0x%x,", mx);
682
0
                          printf ("  ss = 0x%x,", ss);
683
0
                          printf ("  rsrc = 0x%x,", rsrc);
684
0
                          printf ("  rdst = 0x%x\n", rdst);
685
0
                        }
686
3.76k
                      SYNTAX("and %1%S1, %0");
687
3.76k
#line 444 "rx-decode.opc"
688
3.76k
                      ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
689
690
3.76k
                    }
691
3.76k
                  break;
692
258
              }
693
3.76k
            break;
694
3.76k
          case 0x11:
695
189
              GETBYTE ();
696
189
              switch (op[2] & 0x00)
697
189
              {
698
189
                case 0x00:
699
189
                  goto op_semantics_5;
700
0
                  break;
701
189
              }
702
0
            break;
703
590
          case 0x12:
704
590
              GETBYTE ();
705
590
              switch (op[2] & 0x00)
706
590
              {
707
590
                case 0x00:
708
590
                  goto op_semantics_5;
709
0
                  break;
710
590
              }
711
0
            break;
712
590
          case 0x13:
713
590
              GETBYTE ();
714
590
              switch (op[2] & 0x00)
715
590
              {
716
590
                case 0x00:
717
590
                  goto op_semantics_5;
718
0
                  break;
719
590
              }
720
0
            break;
721
104
          case 0x14:
722
104
              GETBYTE ();
723
104
              switch (op[2] & 0x00)
724
104
              {
725
104
                case 0x00:
726
2.46k
                  op_semantics_6:
727
2.46k
                    {
728
                      /** 0000 0110 mx01 01ss rsrc rdst     or  %1%S1, %0 */
729
2.46k
#line 462 "rx-decode.opc"
730
2.46k
                      int mx AU = (op[1] >> 6) & 0x03;
731
2.46k
#line 462 "rx-decode.opc"
732
2.46k
                      int ss AU = op[1] & 0x03;
733
2.46k
#line 462 "rx-decode.opc"
734
2.46k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
735
2.46k
#line 462 "rx-decode.opc"
736
2.46k
                      int rdst AU = op[2] & 0x0f;
737
2.46k
                      if (trace)
738
0
                        {
739
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
740
0
                                 "/** 0000 0110 mx01 01ss rsrc rdst     or  %1%S1, %0 */",
741
0
                                 op[0], op[1], op[2]);
742
0
                          printf ("  mx = 0x%x,", mx);
743
0
                          printf ("  ss = 0x%x,", ss);
744
0
                          printf ("  rsrc = 0x%x,", rsrc);
745
0
                          printf ("  rdst = 0x%x\n", rdst);
746
0
                        }
747
2.46k
                      SYNTAX("or  %1%S1, %0");
748
2.46k
#line 462 "rx-decode.opc"
749
2.46k
                      ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
750
751
2.46k
                    }
752
2.46k
                  break;
753
104
              }
754
2.46k
            break;
755
2.46k
          case 0x15:
756
382
              GETBYTE ();
757
382
              switch (op[2] & 0x00)
758
382
              {
759
377
                case 0x00:
760
377
                  goto op_semantics_6;
761
0
                  break;
762
382
              }
763
0
            break;
764
65
          case 0x16:
765
65
              GETBYTE ();
766
65
              switch (op[2] & 0x00)
767
65
              {
768
65
                case 0x00:
769
65
                  goto op_semantics_6;
770
0
                  break;
771
65
              }
772
0
            break;
773
186
          case 0x17:
774
186
              GETBYTE ();
775
186
              switch (op[2] & 0x00)
776
186
              {
777
186
                case 0x00:
778
186
                  goto op_semantics_6;
779
0
                  break;
780
186
              }
781
0
            break;
782
1.23k
          case 0x20:
783
1.23k
              GETBYTE ();
784
1.23k
              switch (op[2] & 0xff)
785
1.23k
              {
786
124
                case 0x00:
787
124
                    GETBYTE ();
788
124
                    switch (op[3] & 0x00)
789
124
                    {
790
124
                      case 0x00:
791
3.09k
                        op_semantics_7:
792
3.09k
                          {
793
                            /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
794
3.09k
#line 580 "rx-decode.opc"
795
3.09k
                            int mx AU = (op[1] >> 6) & 0x03;
796
3.09k
#line 580 "rx-decode.opc"
797
3.09k
                            int sp AU = op[1] & 0x03;
798
3.09k
#line 580 "rx-decode.opc"
799
3.09k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
800
3.09k
#line 580 "rx-decode.opc"
801
3.09k
                            int rdst AU = op[3] & 0x0f;
802
3.09k
                            if (trace)
803
0
                              {
804
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
805
0
                                       "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */",
806
0
                                       op[0], op[1], op[2], op[3]);
807
0
                                printf ("  mx = 0x%x,", mx);
808
0
                                printf ("  sp = 0x%x,", sp);
809
0
                                printf ("  rsrc = 0x%x,", rsrc);
810
0
                                printf ("  rdst = 0x%x\n", rdst);
811
0
                              }
812
3.09k
                            SYNTAX("sbb %1%S1, %0");
813
3.09k
#line 580 "rx-decode.opc"
814
3.09k
                            ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
815
816
                          /*----------------------------------------------------------------------*/
817
                          /* ABS                  */
818
819
3.09k
                          }
820
3.09k
                        break;
821
124
                    }
822
3.09k
                  break;
823
3.09k
                case 0x04:
824
36
                    GETBYTE ();
825
36
                    switch (op[3] & 0x00)
826
36
                    {
827
36
                      case 0x00:
828
1.58k
                        op_semantics_8:
829
1.58k
                          {
830
                            /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
831
1.58k
#line 619 "rx-decode.opc"
832
1.58k
                            int mx AU = (op[1] >> 6) & 0x03;
833
1.58k
#line 619 "rx-decode.opc"
834
1.58k
                            int ss AU = op[1] & 0x03;
835
1.58k
#line 619 "rx-decode.opc"
836
1.58k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
837
1.58k
#line 619 "rx-decode.opc"
838
1.58k
                            int rdst AU = op[3] & 0x0f;
839
1.58k
                            if (trace)
840
0
                              {
841
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
842
0
                                       "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */",
843
0
                                       op[0], op[1], op[2], op[3]);
844
0
                                printf ("  mx = 0x%x,", mx);
845
0
                                printf ("  ss = 0x%x,", ss);
846
0
                                printf ("  rsrc = 0x%x,", rsrc);
847
0
                                printf ("  rdst = 0x%x\n", rdst);
848
0
                              }
849
1.58k
                            SYNTAX("max %1%S1, %0");
850
1.58k
#line 619 "rx-decode.opc"
851
1.58k
                            ID(max); SPm(ss, rsrc, mx); DR(rdst);
852
853
                          /*----------------------------------------------------------------------*/
854
                          /* MIN                  */
855
856
1.58k
                          }
857
1.58k
                        break;
858
36
                    }
859
1.58k
                  break;
860
1.58k
                case 0x05:
861
24
                    GETBYTE ();
862
24
                    switch (op[3] & 0x00)
863
24
                    {
864
24
                      case 0x00:
865
2.25k
                        op_semantics_9:
866
2.25k
                          {
867
                            /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
868
2.25k
#line 631 "rx-decode.opc"
869
2.25k
                            int mx AU = (op[1] >> 6) & 0x03;
870
2.25k
#line 631 "rx-decode.opc"
871
2.25k
                            int ss AU = op[1] & 0x03;
872
2.25k
#line 631 "rx-decode.opc"
873
2.25k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
874
2.25k
#line 631 "rx-decode.opc"
875
2.25k
                            int rdst AU = op[3] & 0x0f;
876
2.25k
                            if (trace)
877
0
                              {
878
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
879
0
                                       "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */",
880
0
                                       op[0], op[1], op[2], op[3]);
881
0
                                printf ("  mx = 0x%x,", mx);
882
0
                                printf ("  ss = 0x%x,", ss);
883
0
                                printf ("  rsrc = 0x%x,", rsrc);
884
0
                                printf ("  rdst = 0x%x\n", rdst);
885
0
                              }
886
2.25k
                            SYNTAX("min %1%S1, %0");
887
2.25k
#line 631 "rx-decode.opc"
888
2.25k
                            ID(min); SPm(ss, rsrc, mx); DR(rdst);
889
890
                          /*----------------------------------------------------------------------*/
891
                          /* MUL                  */
892
893
2.25k
                          }
894
2.25k
                        break;
895
24
                    }
896
2.24k
                  break;
897
2.24k
                case 0x06:
898
182
                    GETBYTE ();
899
182
                    switch (op[3] & 0x00)
900
182
                    {
901
182
                      case 0x00:
902
967
                        op_semantics_10:
903
967
                          {
904
                            /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul  %1%S1, %0 */
905
967
#line 689 "rx-decode.opc"
906
967
                            int mx AU = (op[1] >> 6) & 0x03;
907
967
#line 689 "rx-decode.opc"
908
967
                            int ss AU = op[1] & 0x03;
909
967
#line 689 "rx-decode.opc"
910
967
                            int rsrc AU = (op[3] >> 4) & 0x0f;
911
967
#line 689 "rx-decode.opc"
912
967
                            int rdst AU = op[3] & 0x0f;
913
967
                            if (trace)
914
0
                              {
915
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
916
0
                                       "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul  %1%S1, %0 */",
917
0
                                       op[0], op[1], op[2], op[3]);
918
0
                                printf ("  mx = 0x%x,", mx);
919
0
                                printf ("  ss = 0x%x,", ss);
920
0
                                printf ("  rsrc = 0x%x,", rsrc);
921
0
                                printf ("  rdst = 0x%x\n", rdst);
922
0
                              }
923
967
                            SYNTAX("emul  %1%S1, %0");
924
967
#line 689 "rx-decode.opc"
925
967
                            ID(emul); SPm(ss, rsrc, mx); DR(rdst);
926
927
                          /*----------------------------------------------------------------------*/
928
                          /* EMULU                  */
929
930
967
                          }
931
967
                        break;
932
182
                    }
933
967
                  break;
934
967
                case 0x07:
935
0
                    GETBYTE ();
936
0
                    switch (op[3] & 0x00)
937
0
                    {
938
0
                      case 0x00:
939
835
                        op_semantics_11:
940
835
                          {
941
                            /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
942
835
#line 701 "rx-decode.opc"
943
835
                            int mx AU = (op[1] >> 6) & 0x03;
944
835
#line 701 "rx-decode.opc"
945
835
                            int ss AU = op[1] & 0x03;
946
835
#line 701 "rx-decode.opc"
947
835
                            int rsrc AU = (op[3] >> 4) & 0x0f;
948
835
#line 701 "rx-decode.opc"
949
835
                            int rdst AU = op[3] & 0x0f;
950
835
                            if (trace)
951
0
                              {
952
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
953
0
                                       "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */",
954
0
                                       op[0], op[1], op[2], op[3]);
955
0
                                printf ("  mx = 0x%x,", mx);
956
0
                                printf ("  ss = 0x%x,", ss);
957
0
                                printf ("  rsrc = 0x%x,", rsrc);
958
0
                                printf ("  rdst = 0x%x\n", rdst);
959
0
                              }
960
835
                            SYNTAX("emulu %1%S1, %0");
961
835
#line 701 "rx-decode.opc"
962
835
                            ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
963
964
                          /*----------------------------------------------------------------------*/
965
                          /* DIV                  */
966
967
835
                          }
968
835
                        break;
969
0
                    }
970
835
                  break;
971
835
                case 0x08:
972
130
                    GETBYTE ();
973
130
                    switch (op[3] & 0x00)
974
130
                    {
975
130
                      case 0x00:
976
1.01k
                        op_semantics_12:
977
1.01k
                          {
978
                            /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
979
1.01k
#line 713 "rx-decode.opc"
980
1.01k
                            int mx AU = (op[1] >> 6) & 0x03;
981
1.01k
#line 713 "rx-decode.opc"
982
1.01k
                            int ss AU = op[1] & 0x03;
983
1.01k
#line 713 "rx-decode.opc"
984
1.01k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
985
1.01k
#line 713 "rx-decode.opc"
986
1.01k
                            int rdst AU = op[3] & 0x0f;
987
1.01k
                            if (trace)
988
0
                              {
989
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
990
0
                                       "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */",
991
0
                                       op[0], op[1], op[2], op[3]);
992
0
                                printf ("  mx = 0x%x,", mx);
993
0
                                printf ("  ss = 0x%x,", ss);
994
0
                                printf ("  rsrc = 0x%x,", rsrc);
995
0
                                printf ("  rdst = 0x%x\n", rdst);
996
0
                              }
997
1.01k
                            SYNTAX("div %1%S1, %0");
998
1.01k
#line 713 "rx-decode.opc"
999
1.01k
                            ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1000
1001
                          /*----------------------------------------------------------------------*/
1002
                          /* DIVU                 */
1003
1004
1.01k
                          }
1005
1.01k
                        break;
1006
130
                    }
1007
1.01k
                  break;
1008
1.01k
                case 0x09:
1009
5
                    GETBYTE ();
1010
5
                    switch (op[3] & 0x00)
1011
5
                    {
1012
5
                      case 0x00:
1013
625
                        op_semantics_13:
1014
625
                          {
1015
                            /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu  %1%S1, %0 */
1016
625
#line 725 "rx-decode.opc"
1017
625
                            int mx AU = (op[1] >> 6) & 0x03;
1018
625
#line 725 "rx-decode.opc"
1019
625
                            int ss AU = op[1] & 0x03;
1020
625
#line 725 "rx-decode.opc"
1021
625
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1022
625
#line 725 "rx-decode.opc"
1023
625
                            int rdst AU = op[3] & 0x0f;
1024
625
                            if (trace)
1025
0
                              {
1026
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1027
0
                                       "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu  %1%S1, %0 */",
1028
0
                                       op[0], op[1], op[2], op[3]);
1029
0
                                printf ("  mx = 0x%x,", mx);
1030
0
                                printf ("  ss = 0x%x,", ss);
1031
0
                                printf ("  rsrc = 0x%x,", rsrc);
1032
0
                                printf ("  rdst = 0x%x\n", rdst);
1033
0
                              }
1034
625
                            SYNTAX("divu  %1%S1, %0");
1035
625
#line 725 "rx-decode.opc"
1036
625
                            ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1037
1038
                          /*----------------------------------------------------------------------*/
1039
                          /* SHIFT                */
1040
1041
625
                          }
1042
625
                        break;
1043
5
                    }
1044
625
                  break;
1045
625
                case 0x0c:
1046
233
                    GETBYTE ();
1047
233
                    switch (op[3] & 0x00)
1048
233
                    {
1049
233
                      case 0x00:
1050
950
                        op_semantics_14:
1051
950
                          {
1052
                            /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1053
950
#line 498 "rx-decode.opc"
1054
950
                            int mx AU = (op[1] >> 6) & 0x03;
1055
950
#line 498 "rx-decode.opc"
1056
950
                            int ss AU = op[1] & 0x03;
1057
950
#line 498 "rx-decode.opc"
1058
950
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1059
950
#line 498 "rx-decode.opc"
1060
950
                            int rdst AU = op[3] & 0x0f;
1061
950
                            if (trace)
1062
0
                              {
1063
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1064
0
                                       "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */",
1065
0
                                       op[0], op[1], op[2], op[3]);
1066
0
                                printf ("  mx = 0x%x,", mx);
1067
0
                                printf ("  ss = 0x%x,", ss);
1068
0
                                printf ("  rsrc = 0x%x,", rsrc);
1069
0
                                printf ("  rdst = 0x%x\n", rdst);
1070
0
                              }
1071
950
                            SYNTAX("tst %1%S1, %2");
1072
950
#line 498 "rx-decode.opc"
1073
950
                            ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1074
1075
                          /*----------------------------------------------------------------------*/
1076
                          /* NEG                  */
1077
1078
950
                          }
1079
950
                        break;
1080
233
                    }
1081
950
                  break;
1082
950
                case 0x0d:
1083
235
                    GETBYTE ();
1084
235
                    switch (op[3] & 0x00)
1085
235
                    {
1086
235
                      case 0x00:
1087
556
                        op_semantics_15:
1088
556
                          {
1089
                            /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1090
556
#line 477 "rx-decode.opc"
1091
556
                            int mx AU = (op[1] >> 6) & 0x03;
1092
556
#line 477 "rx-decode.opc"
1093
556
                            int ss AU = op[1] & 0x03;
1094
556
#line 477 "rx-decode.opc"
1095
556
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1096
556
#line 477 "rx-decode.opc"
1097
556
                            int rdst AU = op[3] & 0x0f;
1098
556
                            if (trace)
1099
0
                              {
1100
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1101
0
                                       "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */",
1102
0
                                       op[0], op[1], op[2], op[3]);
1103
0
                                printf ("  mx = 0x%x,", mx);
1104
0
                                printf ("  ss = 0x%x,", ss);
1105
0
                                printf ("  rsrc = 0x%x,", rsrc);
1106
0
                                printf ("  rdst = 0x%x\n", rdst);
1107
0
                              }
1108
556
                            SYNTAX("xor %1%S1, %0");
1109
556
#line 477 "rx-decode.opc"
1110
556
                            ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1111
1112
                          /*----------------------------------------------------------------------*/
1113
                          /* NOT                  */
1114
1115
556
                          }
1116
556
                        break;
1117
235
                    }
1118
555
                  break;
1119
555
                case 0x10:
1120
30
                    GETBYTE ();
1121
30
                    switch (op[3] & 0x00)
1122
30
                    {
1123
30
                      case 0x00:
1124
2.24k
                        op_semantics_16:
1125
2.24k
                          {
1126
                            /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg  %1%S1, %0 */
1127
2.24k
#line 411 "rx-decode.opc"
1128
2.24k
                            int mx AU = (op[1] >> 6) & 0x03;
1129
2.24k
#line 411 "rx-decode.opc"
1130
2.24k
                            int ss AU = op[1] & 0x03;
1131
2.24k
#line 411 "rx-decode.opc"
1132
2.24k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1133
2.24k
#line 411 "rx-decode.opc"
1134
2.24k
                            int rdst AU = op[3] & 0x0f;
1135
2.24k
                            if (trace)
1136
0
                              {
1137
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1138
0
                                       "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg  %1%S1, %0 */",
1139
0
                                       op[0], op[1], op[2], op[3]);
1140
0
                                printf ("  mx = 0x%x,", mx);
1141
0
                                printf ("  ss = 0x%x,", ss);
1142
0
                                printf ("  rsrc = 0x%x,", rsrc);
1143
0
                                printf ("  rdst = 0x%x\n", rdst);
1144
0
                              }
1145
2.24k
                            SYNTAX("xchg  %1%S1, %0");
1146
2.24k
#line 411 "rx-decode.opc"
1147
2.24k
                            ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1148
1149
                          /*----------------------------------------------------------------------*/
1150
                          /* STZ/STNZ               */
1151
1152
2.24k
                          }
1153
2.24k
                        break;
1154
30
                    }
1155
2.24k
                  break;
1156
2.24k
                case 0x11:
1157
2
                    GETBYTE ();
1158
2
                    switch (op[3] & 0x00)
1159
2
                    {
1160
2
                      case 0x00:
1161
1.18k
                        op_semantics_17:
1162
1.18k
                          {
1163
                            /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof  %1%S1, %0 */
1164
1.18k
#line 954 "rx-decode.opc"
1165
1.18k
                            int mx AU = (op[1] >> 6) & 0x03;
1166
1.18k
#line 954 "rx-decode.opc"
1167
1.18k
                            int sd AU = op[1] & 0x03;
1168
1.18k
#line 954 "rx-decode.opc"
1169
1.18k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1170
1.18k
#line 954 "rx-decode.opc"
1171
1.18k
                            int rdst AU = op[3] & 0x0f;
1172
1.18k
                            if (trace)
1173
0
                              {
1174
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1175
0
                                       "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof  %1%S1, %0 */",
1176
0
                                       op[0], op[1], op[2], op[3]);
1177
0
                                printf ("  mx = 0x%x,", mx);
1178
0
                                printf ("  sd = 0x%x,", sd);
1179
0
                                printf ("  rsrc = 0x%x,", rsrc);
1180
0
                                printf ("  rdst = 0x%x\n", rdst);
1181
0
                              }
1182
1.18k
                            SYNTAX("itof  %1%S1, %0");
1183
1.18k
#line 954 "rx-decode.opc"
1184
1.18k
                            ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1185
1186
                          /*----------------------------------------------------------------------*/
1187
                          /* BIT OPS                */
1188
1189
1.18k
                          }
1190
1.18k
                        break;
1191
2
                    }
1192
1.18k
                  break;
1193
1.18k
                case 0x15:
1194
0
                    GETBYTE ();
1195
0
                    switch (op[3] & 0x00)
1196
0
                    {
1197
0
                      case 0x00:
1198
955
                        op_semantics_18:
1199
955
                          {
1200
                            /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof  %1%S1, %0 */
1201
955
#line 1140 "rx-decode.opc"
1202
955
                            int mx AU = (op[1] >> 6) & 0x03;
1203
955
#line 1140 "rx-decode.opc"
1204
955
                            int sd AU = op[1] & 0x03;
1205
955
#line 1140 "rx-decode.opc"
1206
955
                            int rsrc AU = (op[3] >> 4) & 0x0f;
1207
955
#line 1140 "rx-decode.opc"
1208
955
                            int rdst AU = op[3] & 0x0f;
1209
955
                            if (trace)
1210
0
                              {
1211
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1212
0
                                       "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof  %1%S1, %0 */",
1213
0
                                       op[0], op[1], op[2], op[3]);
1214
0
                                printf ("  mx = 0x%x,", mx);
1215
0
                                printf ("  sd = 0x%x,", sd);
1216
0
                                printf ("  rsrc = 0x%x,", rsrc);
1217
0
                                printf ("  rdst = 0x%x\n", rdst);
1218
0
                              }
1219
955
                            SYNTAX("utof  %1%S1, %0");
1220
955
#line 1140 "rx-decode.opc"
1221
955
                            ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1222
1223
                          /*----------------------------------------------------------------------*/
1224
                          /* RXv3 enhanced              */
1225
1226
955
                          }
1227
955
                        break;
1228
0
                    }
1229
952
                  break;
1230
952
                default: UNSUPPORTED(); break;
1231
1.23k
              }
1232
16.4k
            break;
1233
16.4k
          case 0x21:
1234
813
              GETBYTE ();
1235
813
              switch (op[2] & 0xff)
1236
813
              {
1237
129
                case 0x00:
1238
129
                    GETBYTE ();
1239
129
                    switch (op[3] & 0x00)
1240
129
                    {
1241
129
                      case 0x00:
1242
129
                        goto op_semantics_7;
1243
0
                        break;
1244
129
                    }
1245
0
                  break;
1246
6
                case 0x04:
1247
6
                    GETBYTE ();
1248
6
                    switch (op[3] & 0x00)
1249
6
                    {
1250
6
                      case 0x00:
1251
6
                        goto op_semantics_8;
1252
0
                        break;
1253
6
                    }
1254
0
                  break;
1255
1
                case 0x05:
1256
1
                    GETBYTE ();
1257
1
                    switch (op[3] & 0x00)
1258
1
                    {
1259
1
                      case 0x00:
1260
1
                        goto op_semantics_9;
1261
0
                        break;
1262
1
                    }
1263
0
                  break;
1264
25
                case 0x06:
1265
25
                    GETBYTE ();
1266
25
                    switch (op[3] & 0x00)
1267
25
                    {
1268
25
                      case 0x00:
1269
25
                        goto op_semantics_10;
1270
0
                        break;
1271
25
                    }
1272
0
                  break;
1273
39
                case 0x07:
1274
39
                    GETBYTE ();
1275
39
                    switch (op[3] & 0x00)
1276
39
                    {
1277
39
                      case 0x00:
1278
39
                        goto op_semantics_11;
1279
0
                        break;
1280
39
                    }
1281
0
                  break;
1282
25
                case 0x08:
1283
25
                    GETBYTE ();
1284
25
                    switch (op[3] & 0x00)
1285
25
                    {
1286
25
                      case 0x00:
1287
25
                        goto op_semantics_12;
1288
0
                        break;
1289
25
                    }
1290
0
                  break;
1291
0
                case 0x09:
1292
0
                    GETBYTE ();
1293
0
                    switch (op[3] & 0x00)
1294
0
                    {
1295
0
                      case 0x00:
1296
0
                        goto op_semantics_13;
1297
0
                        break;
1298
0
                    }
1299
0
                  break;
1300
79
                case 0x0c:
1301
79
                    GETBYTE ();
1302
79
                    switch (op[3] & 0x00)
1303
79
                    {
1304
79
                      case 0x00:
1305
79
                        goto op_semantics_14;
1306
0
                        break;
1307
79
                    }
1308
0
                  break;
1309
106
                case 0x0d:
1310
106
                    GETBYTE ();
1311
106
                    switch (op[3] & 0x00)
1312
106
                    {
1313
106
                      case 0x00:
1314
106
                        goto op_semantics_15;
1315
0
                        break;
1316
106
                    }
1317
0
                  break;
1318
120
                case 0x10:
1319
120
                    GETBYTE ();
1320
120
                    switch (op[3] & 0x00)
1321
120
                    {
1322
120
                      case 0x00:
1323
120
                        goto op_semantics_16;
1324
0
                        break;
1325
120
                    }
1326
0
                  break;
1327
119
                case 0x11:
1328
119
                    GETBYTE ();
1329
119
                    switch (op[3] & 0x00)
1330
119
                    {
1331
119
                      case 0x00:
1332
119
                        goto op_semantics_17;
1333
0
                        break;
1334
119
                    }
1335
0
                  break;
1336
0
                case 0x15:
1337
0
                    GETBYTE ();
1338
0
                    switch (op[3] & 0x00)
1339
0
                    {
1340
0
                      case 0x00:
1341
0
                        goto op_semantics_18;
1342
0
                        break;
1343
0
                    }
1344
0
                  break;
1345
164
                default: UNSUPPORTED(); break;
1346
813
              }
1347
164
            break;
1348
1.39k
          case 0x22:
1349
1.39k
              GETBYTE ();
1350
1.39k
              switch (op[2] & 0xff)
1351
1.39k
              {
1352
142
                case 0x00:
1353
142
                    GETBYTE ();
1354
142
                    switch (op[3] & 0x00)
1355
142
                    {
1356
142
                      case 0x00:
1357
142
                        goto op_semantics_7;
1358
0
                        break;
1359
142
                    }
1360
0
                  break;
1361
134
                case 0x04:
1362
134
                    GETBYTE ();
1363
134
                    switch (op[3] & 0x00)
1364
134
                    {
1365
132
                      case 0x00:
1366
132
                        goto op_semantics_8;
1367
0
                        break;
1368
134
                    }
1369
0
                  break;
1370
31
                case 0x05:
1371
31
                    GETBYTE ();
1372
31
                    switch (op[3] & 0x00)
1373
31
                    {
1374
9
                      case 0x00:
1375
9
                        goto op_semantics_9;
1376
0
                        break;
1377
31
                    }
1378
0
                  break;
1379
8
                case 0x06:
1380
8
                    GETBYTE ();
1381
8
                    switch (op[3] & 0x00)
1382
8
                    {
1383
3
                      case 0x00:
1384
3
                        goto op_semantics_10;
1385
0
                        break;
1386
8
                    }
1387
0
                  break;
1388
10
                case 0x07:
1389
10
                    GETBYTE ();
1390
10
                    switch (op[3] & 0x00)
1391
10
                    {
1392
10
                      case 0x00:
1393
10
                        goto op_semantics_11;
1394
0
                        break;
1395
10
                    }
1396
0
                  break;
1397
18
                case 0x08:
1398
18
                    GETBYTE ();
1399
18
                    switch (op[3] & 0x00)
1400
18
                    {
1401
18
                      case 0x00:
1402
18
                        goto op_semantics_12;
1403
0
                        break;
1404
18
                    }
1405
0
                  break;
1406
20
                case 0x09:
1407
20
                    GETBYTE ();
1408
20
                    switch (op[3] & 0x00)
1409
20
                    {
1410
20
                      case 0x00:
1411
20
                        goto op_semantics_13;
1412
0
                        break;
1413
20
                    }
1414
0
                  break;
1415
41
                case 0x0c:
1416
41
                    GETBYTE ();
1417
41
                    switch (op[3] & 0x00)
1418
41
                    {
1419
41
                      case 0x00:
1420
41
                        goto op_semantics_14;
1421
0
                        break;
1422
41
                    }
1423
0
                  break;
1424
1
                case 0x0d:
1425
1
                    GETBYTE ();
1426
1
                    switch (op[3] & 0x00)
1427
1
                    {
1428
1
                      case 0x00:
1429
1
                        goto op_semantics_15;
1430
0
                        break;
1431
1
                    }
1432
0
                  break;
1433
42
                case 0x10:
1434
42
                    GETBYTE ();
1435
42
                    switch (op[3] & 0x00)
1436
42
                    {
1437
42
                      case 0x00:
1438
42
                        goto op_semantics_16;
1439
0
                        break;
1440
42
                    }
1441
0
                  break;
1442
92
                case 0x11:
1443
92
                    GETBYTE ();
1444
92
                    switch (op[3] & 0x00)
1445
92
                    {
1446
91
                      case 0x00:
1447
91
                        goto op_semantics_17;
1448
0
                        break;
1449
92
                    }
1450
0
                  break;
1451
150
                case 0x15:
1452
150
                    GETBYTE ();
1453
150
                    switch (op[3] & 0x00)
1454
150
                    {
1455
150
                      case 0x00:
1456
150
                        goto op_semantics_18;
1457
0
                        break;
1458
150
                    }
1459
0
                  break;
1460
705
                default: UNSUPPORTED(); break;
1461
1.39k
              }
1462
705
            break;
1463
1.59k
          case 0x23:
1464
1.59k
              GETBYTE ();
1465
1.59k
              switch (op[2] & 0xff)
1466
1.59k
              {
1467
250
                case 0x00:
1468
250
                    GETBYTE ();
1469
250
                    switch (op[3] & 0x00)
1470
250
                    {
1471
250
                      case 0x00:
1472
250
                        goto op_semantics_7;
1473
0
                        break;
1474
250
                    }
1475
0
                  break;
1476
24
                case 0x04:
1477
24
                    GETBYTE ();
1478
24
                    switch (op[3] & 0x00)
1479
24
                    {
1480
24
                      case 0x00:
1481
24
                        goto op_semantics_8;
1482
0
                        break;
1483
24
                    }
1484
0
                  break;
1485
21
                case 0x05:
1486
21
                    GETBYTE ();
1487
21
                    switch (op[3] & 0x00)
1488
21
                    {
1489
21
                      case 0x00:
1490
21
                        goto op_semantics_9;
1491
0
                        break;
1492
21
                    }
1493
0
                  break;
1494
4
                case 0x06:
1495
4
                    GETBYTE ();
1496
4
                    switch (op[3] & 0x00)
1497
4
                    {
1498
4
                      case 0x00:
1499
4
                        goto op_semantics_10;
1500
0
                        break;
1501
4
                    }
1502
0
                  break;
1503
2
                case 0x07:
1504
2
                    GETBYTE ();
1505
2
                    switch (op[3] & 0x00)
1506
2
                    {
1507
2
                      case 0x00:
1508
2
                        goto op_semantics_11;
1509
0
                        break;
1510
2
                    }
1511
0
                  break;
1512
132
                case 0x08:
1513
132
                    GETBYTE ();
1514
132
                    switch (op[3] & 0x00)
1515
132
                    {
1516
132
                      case 0x00:
1517
132
                        goto op_semantics_12;
1518
0
                        break;
1519
132
                    }
1520
0
                  break;
1521
32
                case 0x09:
1522
32
                    GETBYTE ();
1523
32
                    switch (op[3] & 0x00)
1524
32
                    {
1525
32
                      case 0x00:
1526
32
                        goto op_semantics_13;
1527
0
                        break;
1528
32
                    }
1529
0
                  break;
1530
27
                case 0x0c:
1531
27
                    GETBYTE ();
1532
27
                    switch (op[3] & 0x00)
1533
27
                    {
1534
27
                      case 0x00:
1535
27
                        goto op_semantics_14;
1536
0
                        break;
1537
27
                    }
1538
0
                  break;
1539
1
                case 0x0d:
1540
1
                    GETBYTE ();
1541
1
                    switch (op[3] & 0x00)
1542
1
                    {
1543
1
                      case 0x00:
1544
1
                        goto op_semantics_15;
1545
0
                        break;
1546
1
                    }
1547
0
                  break;
1548
179
                case 0x10:
1549
179
                    GETBYTE ();
1550
179
                    switch (op[3] & 0x00)
1551
179
                    {
1552
179
                      case 0x00:
1553
179
                        goto op_semantics_16;
1554
0
                        break;
1555
179
                    }
1556
0
                  break;
1557
57
                case 0x11:
1558
57
                    GETBYTE ();
1559
57
                    switch (op[3] & 0x00)
1560
57
                    {
1561
57
                      case 0x00:
1562
57
                        goto op_semantics_17;
1563
0
                        break;
1564
57
                    }
1565
0
                  break;
1566
0
                case 0x15:
1567
0
                    GETBYTE ();
1568
0
                    switch (op[3] & 0x00)
1569
0
                    {
1570
0
                      case 0x00:
1571
0
                        goto op_semantics_18;
1572
0
                        break;
1573
0
                    }
1574
0
                  break;
1575
864
                default: UNSUPPORTED(); break;
1576
1.59k
              }
1577
864
            break;
1578
864
          case 0x40:
1579
742
              GETBYTE ();
1580
742
              switch (op[2] & 0x00)
1581
742
              {
1582
742
                case 0x00:
1583
742
                  goto op_semantics_1;
1584
0
                  break;
1585
742
              }
1586
0
            break;
1587
162
          case 0x41:
1588
162
              GETBYTE ();
1589
162
              switch (op[2] & 0x00)
1590
162
              {
1591
162
                case 0x00:
1592
162
                  goto op_semantics_1;
1593
0
                  break;
1594
162
              }
1595
0
            break;
1596
89
          case 0x42:
1597
89
              GETBYTE ();
1598
89
              switch (op[2] & 0x00)
1599
89
              {
1600
89
                case 0x00:
1601
89
                  goto op_semantics_1;
1602
0
                  break;
1603
89
              }
1604
0
            break;
1605
74
          case 0x43:
1606
74
              GETBYTE ();
1607
74
              switch (op[2] & 0x00)
1608
74
              {
1609
73
                case 0x00:
1610
73
                  goto op_semantics_1;
1611
0
                  break;
1612
74
              }
1613
0
            break;
1614
37
          case 0x44:
1615
37
              GETBYTE ();
1616
37
              switch (op[2] & 0x00)
1617
37
              {
1618
37
                case 0x00:
1619
37
                  goto op_semantics_2;
1620
0
                  break;
1621
37
              }
1622
0
            break;
1623
33
          case 0x45:
1624
33
              GETBYTE ();
1625
33
              switch (op[2] & 0x00)
1626
33
              {
1627
33
                case 0x00:
1628
33
                  goto op_semantics_2;
1629
0
                  break;
1630
33
              }
1631
0
            break;
1632
345
          case 0x46:
1633
345
              GETBYTE ();
1634
345
              switch (op[2] & 0x00)
1635
345
              {
1636
345
                case 0x00:
1637
345
                  goto op_semantics_2;
1638
0
                  break;
1639
345
              }
1640
0
            break;
1641
156
          case 0x47:
1642
156
              GETBYTE ();
1643
156
              switch (op[2] & 0x00)
1644
156
              {
1645
156
                case 0x00:
1646
156
                  goto op_semantics_2;
1647
0
                  break;
1648
156
              }
1649
0
            break;
1650
66
          case 0x48:
1651
66
              GETBYTE ();
1652
66
              switch (op[2] & 0x00)
1653
66
              {
1654
66
                case 0x00:
1655
66
                  goto op_semantics_3;
1656
0
                  break;
1657
66
              }
1658
0
            break;
1659
315
          case 0x49:
1660
315
              GETBYTE ();
1661
315
              switch (op[2] & 0x00)
1662
315
              {
1663
315
                case 0x00:
1664
315
                  goto op_semantics_3;
1665
0
                  break;
1666
315
              }
1667
0
            break;
1668
39
          case 0x4a:
1669
39
              GETBYTE ();
1670
39
              switch (op[2] & 0x00)
1671
39
              {
1672
39
                case 0x00:
1673
39
                  goto op_semantics_3;
1674
0
                  break;
1675
39
              }
1676
0
            break;
1677
81
          case 0x4b:
1678
81
              GETBYTE ();
1679
81
              switch (op[2] & 0x00)
1680
81
              {
1681
81
                case 0x00:
1682
81
                  goto op_semantics_3;
1683
0
                  break;
1684
81
              }
1685
0
            break;
1686
344
          case 0x4c:
1687
344
              GETBYTE ();
1688
344
              switch (op[2] & 0x00)
1689
344
              {
1690
344
                case 0x00:
1691
344
                  goto op_semantics_4;
1692
0
                  break;
1693
344
              }
1694
0
            break;
1695
106
          case 0x4d:
1696
106
              GETBYTE ();
1697
106
              switch (op[2] & 0x00)
1698
106
              {
1699
106
                case 0x00:
1700
106
                  goto op_semantics_4;
1701
0
                  break;
1702
106
              }
1703
0
            break;
1704
226
          case 0x4e:
1705
226
              GETBYTE ();
1706
226
              switch (op[2] & 0x00)
1707
226
              {
1708
226
                case 0x00:
1709
226
                  goto op_semantics_4;
1710
0
                  break;
1711
226
              }
1712
0
            break;
1713
370
          case 0x4f:
1714
370
              GETBYTE ();
1715
370
              switch (op[2] & 0x00)
1716
370
              {
1717
370
                case 0x00:
1718
370
                  goto op_semantics_4;
1719
0
                  break;
1720
370
              }
1721
0
            break;
1722
236
          case 0x50:
1723
236
              GETBYTE ();
1724
236
              switch (op[2] & 0x00)
1725
236
              {
1726
236
                case 0x00:
1727
236
                  goto op_semantics_5;
1728
0
                  break;
1729
236
              }
1730
0
            break;
1731
339
          case 0x51:
1732
339
              GETBYTE ();
1733
339
              switch (op[2] & 0x00)
1734
339
              {
1735
339
                case 0x00:
1736
339
                  goto op_semantics_5;
1737
0
                  break;
1738
339
              }
1739
0
            break;
1740
32
          case 0x52:
1741
32
              GETBYTE ();
1742
32
              switch (op[2] & 0x00)
1743
32
              {
1744
32
                case 0x00:
1745
32
                  goto op_semantics_5;
1746
0
                  break;
1747
32
              }
1748
0
            break;
1749
107
          case 0x53:
1750
107
              GETBYTE ();
1751
107
              switch (op[2] & 0x00)
1752
107
              {
1753
107
                case 0x00:
1754
107
                  goto op_semantics_5;
1755
0
                  break;
1756
107
              }
1757
0
            break;
1758
123
          case 0x54:
1759
123
              GETBYTE ();
1760
123
              switch (op[2] & 0x00)
1761
123
              {
1762
123
                case 0x00:
1763
123
                  goto op_semantics_6;
1764
0
                  break;
1765
123
              }
1766
0
            break;
1767
56
          case 0x55:
1768
56
              GETBYTE ();
1769
56
              switch (op[2] & 0x00)
1770
56
              {
1771
56
                case 0x00:
1772
56
                  goto op_semantics_6;
1773
0
                  break;
1774
56
              }
1775
0
            break;
1776
545
          case 0x56:
1777
545
              GETBYTE ();
1778
545
              switch (op[2] & 0x00)
1779
545
              {
1780
545
                case 0x00:
1781
545
                  goto op_semantics_6;
1782
0
                  break;
1783
545
              }
1784
0
            break;
1785
45
          case 0x57:
1786
45
              GETBYTE ();
1787
45
              switch (op[2] & 0x00)
1788
45
              {
1789
45
                case 0x00:
1790
45
                  goto op_semantics_6;
1791
0
                  break;
1792
45
              }
1793
0
            break;
1794
1.25k
          case 0x60:
1795
1.25k
              GETBYTE ();
1796
1.25k
              switch (op[2] & 0xff)
1797
1.25k
              {
1798
77
                case 0x00:
1799
77
                    GETBYTE ();
1800
77
                    switch (op[3] & 0x00)
1801
77
                    {
1802
77
                      case 0x00:
1803
77
                        goto op_semantics_7;
1804
0
                        break;
1805
77
                    }
1806
0
                  break;
1807
415
                case 0x04:
1808
415
                    GETBYTE ();
1809
415
                    switch (op[3] & 0x00)
1810
415
                    {
1811
415
                      case 0x00:
1812
415
                        goto op_semantics_8;
1813
0
                        break;
1814
415
                    }
1815
0
                  break;
1816
31
                case 0x05:
1817
31
                    GETBYTE ();
1818
31
                    switch (op[3] & 0x00)
1819
31
                    {
1820
31
                      case 0x00:
1821
31
                        goto op_semantics_9;
1822
0
                        break;
1823
31
                    }
1824
0
                  break;
1825
21
                case 0x06:
1826
21
                    GETBYTE ();
1827
21
                    switch (op[3] & 0x00)
1828
21
                    {
1829
21
                      case 0x00:
1830
21
                        goto op_semantics_10;
1831
0
                        break;
1832
21
                    }
1833
0
                  break;
1834
277
                case 0x07:
1835
277
                    GETBYTE ();
1836
277
                    switch (op[3] & 0x00)
1837
277
                    {
1838
277
                      case 0x00:
1839
277
                        goto op_semantics_11;
1840
0
                        break;
1841
277
                    }
1842
0
                  break;
1843
32
                case 0x08:
1844
32
                    GETBYTE ();
1845
32
                    switch (op[3] & 0x00)
1846
32
                    {
1847
32
                      case 0x00:
1848
32
                        goto op_semantics_12;
1849
0
                        break;
1850
32
                    }
1851
0
                  break;
1852
13
                case 0x09:
1853
13
                    GETBYTE ();
1854
13
                    switch (op[3] & 0x00)
1855
13
                    {
1856
13
                      case 0x00:
1857
13
                        goto op_semantics_13;
1858
0
                        break;
1859
13
                    }
1860
0
                  break;
1861
8
                case 0x0c:
1862
8
                    GETBYTE ();
1863
8
                    switch (op[3] & 0x00)
1864
8
                    {
1865
8
                      case 0x00:
1866
8
                        goto op_semantics_14;
1867
0
                        break;
1868
8
                    }
1869
0
                  break;
1870
23
                case 0x0d:
1871
23
                    GETBYTE ();
1872
23
                    switch (op[3] & 0x00)
1873
23
                    {
1874
23
                      case 0x00:
1875
23
                        goto op_semantics_15;
1876
0
                        break;
1877
23
                    }
1878
0
                  break;
1879
50
                case 0x10:
1880
50
                    GETBYTE ();
1881
50
                    switch (op[3] & 0x00)
1882
50
                    {
1883
50
                      case 0x00:
1884
50
                        goto op_semantics_16;
1885
0
                        break;
1886
50
                    }
1887
0
                  break;
1888
20
                case 0x11:
1889
20
                    GETBYTE ();
1890
20
                    switch (op[3] & 0x00)
1891
20
                    {
1892
20
                      case 0x00:
1893
20
                        goto op_semantics_17;
1894
0
                        break;
1895
20
                    }
1896
0
                  break;
1897
0
                case 0x15:
1898
0
                    GETBYTE ();
1899
0
                    switch (op[3] & 0x00)
1900
0
                    {
1901
0
                      case 0x00:
1902
0
                        goto op_semantics_18;
1903
0
                        break;
1904
0
                    }
1905
0
                  break;
1906
283
                default: UNSUPPORTED(); break;
1907
1.25k
              }
1908
283
            break;
1909
1.39k
          case 0x61:
1910
1.39k
              GETBYTE ();
1911
1.39k
              switch (op[2] & 0xff)
1912
1.39k
              {
1913
352
                case 0x00:
1914
352
                    GETBYTE ();
1915
352
                    switch (op[3] & 0x00)
1916
352
                    {
1917
352
                      case 0x00:
1918
352
                        goto op_semantics_7;
1919
0
                        break;
1920
352
                    }
1921
0
                  break;
1922
36
                case 0x04:
1923
36
                    GETBYTE ();
1924
36
                    switch (op[3] & 0x00)
1925
36
                    {
1926
36
                      case 0x00:
1927
36
                        goto op_semantics_8;
1928
0
                        break;
1929
36
                    }
1930
0
                  break;
1931
1
                case 0x05:
1932
1
                    GETBYTE ();
1933
1
                    switch (op[3] & 0x00)
1934
1
                    {
1935
1
                      case 0x00:
1936
1
                        goto op_semantics_9;
1937
0
                        break;
1938
1
                    }
1939
0
                  break;
1940
18
                case 0x06:
1941
18
                    GETBYTE ();
1942
18
                    switch (op[3] & 0x00)
1943
18
                    {
1944
18
                      case 0x00:
1945
18
                        goto op_semantics_10;
1946
0
                        break;
1947
18
                    }
1948
0
                  break;
1949
71
                case 0x07:
1950
71
                    GETBYTE ();
1951
71
                    switch (op[3] & 0x00)
1952
71
                    {
1953
71
                      case 0x00:
1954
71
                        goto op_semantics_11;
1955
0
                        break;
1956
71
                    }
1957
0
                  break;
1958
240
                case 0x08:
1959
240
                    GETBYTE ();
1960
240
                    switch (op[3] & 0x00)
1961
240
                    {
1962
240
                      case 0x00:
1963
240
                        goto op_semantics_12;
1964
0
                        break;
1965
240
                    }
1966
0
                  break;
1967
17
                case 0x09:
1968
17
                    GETBYTE ();
1969
17
                    switch (op[3] & 0x00)
1970
17
                    {
1971
17
                      case 0x00:
1972
17
                        goto op_semantics_13;
1973
0
                        break;
1974
17
                    }
1975
0
                  break;
1976
12
                case 0x0c:
1977
12
                    GETBYTE ();
1978
12
                    switch (op[3] & 0x00)
1979
12
                    {
1980
12
                      case 0x00:
1981
12
                        goto op_semantics_14;
1982
0
                        break;
1983
12
                    }
1984
0
                  break;
1985
7
                case 0x0d:
1986
7
                    GETBYTE ();
1987
7
                    switch (op[3] & 0x00)
1988
7
                    {
1989
7
                      case 0x00:
1990
7
                        goto op_semantics_15;
1991
0
                        break;
1992
7
                    }
1993
0
                  break;
1994
325
                case 0x10:
1995
325
                    GETBYTE ();
1996
325
                    switch (op[3] & 0x00)
1997
325
                    {
1998
325
                      case 0x00:
1999
325
                        goto op_semantics_16;
2000
0
                        break;
2001
325
                    }
2002
0
                  break;
2003
152
                case 0x11:
2004
152
                    GETBYTE ();
2005
152
                    switch (op[3] & 0x00)
2006
152
                    {
2007
152
                      case 0x00:
2008
152
                        goto op_semantics_17;
2009
0
                        break;
2010
152
                    }
2011
0
                  break;
2012
31
                case 0x15:
2013
31
                    GETBYTE ();
2014
31
                    switch (op[3] & 0x00)
2015
31
                    {
2016
31
                      case 0x00:
2017
31
                        goto op_semantics_18;
2018
0
                        break;
2019
31
                    }
2020
0
                  break;
2021
131
                default: UNSUPPORTED(); break;
2022
1.39k
              }
2023
131
            break;
2024
678
          case 0x62:
2025
678
              GETBYTE ();
2026
678
              switch (op[2] & 0xff)
2027
678
              {
2028
199
                case 0x00:
2029
199
                    GETBYTE ();
2030
199
                    switch (op[3] & 0x00)
2031
199
                    {
2032
199
                      case 0x00:
2033
199
                        goto op_semantics_7;
2034
0
                        break;
2035
199
                    }
2036
0
                  break;
2037
39
                case 0x04:
2038
39
                    GETBYTE ();
2039
39
                    switch (op[3] & 0x00)
2040
39
                    {
2041
39
                      case 0x00:
2042
39
                        goto op_semantics_8;
2043
0
                        break;
2044
39
                    }
2045
0
                  break;
2046
39
                case 0x05:
2047
39
                    GETBYTE ();
2048
39
                    switch (op[3] & 0x00)
2049
39
                    {
2050
39
                      case 0x00:
2051
39
                        goto op_semantics_9;
2052
0
                        break;
2053
39
                    }
2054
0
                  break;
2055
1
                case 0x06:
2056
1
                    GETBYTE ();
2057
1
                    switch (op[3] & 0x00)
2058
1
                    {
2059
1
                      case 0x00:
2060
1
                        goto op_semantics_10;
2061
0
                        break;
2062
1
                    }
2063
0
                  break;
2064
86
                case 0x07:
2065
86
                    GETBYTE ();
2066
86
                    switch (op[3] & 0x00)
2067
86
                    {
2068
86
                      case 0x00:
2069
86
                        goto op_semantics_11;
2070
0
                        break;
2071
86
                    }
2072
0
                  break;
2073
24
                case 0x08:
2074
24
                    GETBYTE ();
2075
24
                    switch (op[3] & 0x00)
2076
24
                    {
2077
24
                      case 0x00:
2078
24
                        goto op_semantics_12;
2079
0
                        break;
2080
24
                    }
2081
0
                  break;
2082
69
                case 0x09:
2083
69
                    GETBYTE ();
2084
69
                    switch (op[3] & 0x00)
2085
69
                    {
2086
69
                      case 0x00:
2087
69
                        goto op_semantics_13;
2088
0
                        break;
2089
69
                    }
2090
0
                  break;
2091
0
                case 0x0c:
2092
0
                    GETBYTE ();
2093
0
                    switch (op[3] & 0x00)
2094
0
                    {
2095
0
                      case 0x00:
2096
0
                        goto op_semantics_14;
2097
0
                        break;
2098
0
                    }
2099
0
                  break;
2100
0
                case 0x0d:
2101
0
                    GETBYTE ();
2102
0
                    switch (op[3] & 0x00)
2103
0
                    {
2104
0
                      case 0x00:
2105
0
                        goto op_semantics_15;
2106
0
                        break;
2107
0
                    }
2108
0
                  break;
2109
22
                case 0x10:
2110
22
                    GETBYTE ();
2111
22
                    switch (op[3] & 0x00)
2112
22
                    {
2113
22
                      case 0x00:
2114
22
                        goto op_semantics_16;
2115
0
                        break;
2116
22
                    }
2117
0
                  break;
2118
26
                case 0x11:
2119
26
                    GETBYTE ();
2120
26
                    switch (op[3] & 0x00)
2121
26
                    {
2122
26
                      case 0x00:
2123
26
                        goto op_semantics_17;
2124
0
                        break;
2125
26
                    }
2126
0
                  break;
2127
8
                case 0x15:
2128
8
                    GETBYTE ();
2129
8
                    switch (op[3] & 0x00)
2130
8
                    {
2131
8
                      case 0x00:
2132
8
                        goto op_semantics_18;
2133
0
                        break;
2134
8
                    }
2135
0
                  break;
2136
165
                default: UNSUPPORTED(); break;
2137
678
              }
2138
165
            break;
2139
1.39k
          case 0x63:
2140
1.39k
              GETBYTE ();
2141
1.39k
              switch (op[2] & 0xff)
2142
1.39k
              {
2143
11
                case 0x00:
2144
11
                    GETBYTE ();
2145
11
                    switch (op[3] & 0x00)
2146
11
                    {
2147
10
                      case 0x00:
2148
10
                        goto op_semantics_7;
2149
0
                        break;
2150
11
                    }
2151
0
                  break;
2152
15
                case 0x04:
2153
15
                    GETBYTE ();
2154
15
                    switch (op[3] & 0x00)
2155
15
                    {
2156
15
                      case 0x00:
2157
15
                        goto op_semantics_8;
2158
0
                        break;
2159
15
                    }
2160
0
                  break;
2161
32
                case 0x05:
2162
32
                    GETBYTE ();
2163
32
                    switch (op[3] & 0x00)
2164
32
                    {
2165
32
                      case 0x00:
2166
32
                        goto op_semantics_9;
2167
0
                        break;
2168
32
                    }
2169
0
                  break;
2170
29
                case 0x06:
2171
29
                    GETBYTE ();
2172
29
                    switch (op[3] & 0x00)
2173
29
                    {
2174
29
                      case 0x00:
2175
29
                        goto op_semantics_10;
2176
0
                        break;
2177
29
                    }
2178
0
                  break;
2179
57
                case 0x07:
2180
57
                    GETBYTE ();
2181
57
                    switch (op[3] & 0x00)
2182
57
                    {
2183
57
                      case 0x00:
2184
57
                        goto op_semantics_11;
2185
0
                        break;
2186
57
                    }
2187
0
                  break;
2188
18
                case 0x08:
2189
18
                    GETBYTE ();
2190
18
                    switch (op[3] & 0x00)
2191
18
                    {
2192
18
                      case 0x00:
2193
18
                        goto op_semantics_12;
2194
0
                        break;
2195
18
                    }
2196
0
                  break;
2197
9
                case 0x09:
2198
9
                    GETBYTE ();
2199
9
                    switch (op[3] & 0x00)
2200
9
                    {
2201
9
                      case 0x00:
2202
9
                        goto op_semantics_13;
2203
0
                        break;
2204
9
                    }
2205
0
                  break;
2206
30
                case 0x0c:
2207
30
                    GETBYTE ();
2208
30
                    switch (op[3] & 0x00)
2209
30
                    {
2210
30
                      case 0x00:
2211
30
                        goto op_semantics_14;
2212
0
                        break;
2213
30
                    }
2214
0
                  break;
2215
0
                case 0x0d:
2216
0
                    GETBYTE ();
2217
0
                    switch (op[3] & 0x00)
2218
0
                    {
2219
0
                      case 0x00:
2220
0
                        goto op_semantics_15;
2221
0
                        break;
2222
0
                    }
2223
0
                  break;
2224
941
                case 0x10:
2225
941
                    GETBYTE ();
2226
941
                    switch (op[3] & 0x00)
2227
941
                    {
2228
941
                      case 0x00:
2229
941
                        goto op_semantics_16;
2230
0
                        break;
2231
941
                    }
2232
0
                  break;
2233
24
                case 0x11:
2234
24
                    GETBYTE ();
2235
24
                    switch (op[3] & 0x00)
2236
24
                    {
2237
24
                      case 0x00:
2238
24
                        goto op_semantics_17;
2239
0
                        break;
2240
24
                    }
2241
0
                  break;
2242
4
                case 0x15:
2243
4
                    GETBYTE ();
2244
4
                    switch (op[3] & 0x00)
2245
4
                    {
2246
4
                      case 0x00:
2247
4
                        goto op_semantics_18;
2248
0
                        break;
2249
4
                    }
2250
0
                  break;
2251
227
                default: UNSUPPORTED(); break;
2252
1.39k
              }
2253
227
            break;
2254
552
          case 0x80:
2255
552
              GETBYTE ();
2256
552
              switch (op[2] & 0x00)
2257
552
              {
2258
542
                case 0x00:
2259
542
                  goto op_semantics_1;
2260
0
                  break;
2261
552
              }
2262
0
            break;
2263
39
          case 0x81:
2264
39
              GETBYTE ();
2265
39
              switch (op[2] & 0x00)
2266
39
              {
2267
39
                case 0x00:
2268
39
                  goto op_semantics_1;
2269
0
                  break;
2270
39
              }
2271
0
            break;
2272
439
          case 0x82:
2273
439
              GETBYTE ();
2274
439
              switch (op[2] & 0x00)
2275
439
              {
2276
439
                case 0x00:
2277
439
                  goto op_semantics_1;
2278
0
                  break;
2279
439
              }
2280
0
            break;
2281
277
          case 0x83:
2282
277
              GETBYTE ();
2283
277
              switch (op[2] & 0x00)
2284
277
              {
2285
277
                case 0x00:
2286
277
                  goto op_semantics_1;
2287
0
                  break;
2288
277
              }
2289
0
            break;
2290
1.14k
          case 0x84:
2291
1.14k
              GETBYTE ();
2292
1.14k
              switch (op[2] & 0x00)
2293
1.14k
              {
2294
1.14k
                case 0x00:
2295
1.14k
                  goto op_semantics_2;
2296
0
                  break;
2297
1.14k
              }
2298
0
            break;
2299
153
          case 0x85:
2300
153
              GETBYTE ();
2301
153
              switch (op[2] & 0x00)
2302
153
              {
2303
153
                case 0x00:
2304
153
                  goto op_semantics_2;
2305
0
                  break;
2306
153
              }
2307
0
            break;
2308
60
          case 0x86:
2309
60
              GETBYTE ();
2310
60
              switch (op[2] & 0x00)
2311
60
              {
2312
60
                case 0x00:
2313
60
                  goto op_semantics_2;
2314
0
                  break;
2315
60
              }
2316
0
            break;
2317
28
          case 0x87:
2318
28
              GETBYTE ();
2319
28
              switch (op[2] & 0x00)
2320
28
              {
2321
28
                case 0x00:
2322
28
                  goto op_semantics_2;
2323
0
                  break;
2324
28
              }
2325
0
            break;
2326
48
          case 0x88:
2327
48
              GETBYTE ();
2328
48
              switch (op[2] & 0x00)
2329
48
              {
2330
48
                case 0x00:
2331
48
                  goto op_semantics_3;
2332
0
                  break;
2333
48
              }
2334
0
            break;
2335
201
          case 0x89:
2336
201
              GETBYTE ();
2337
201
              switch (op[2] & 0x00)
2338
201
              {
2339
201
                case 0x00:
2340
201
                  goto op_semantics_3;
2341
0
                  break;
2342
201
              }
2343
0
            break;
2344
68
          case 0x8a:
2345
68
              GETBYTE ();
2346
68
              switch (op[2] & 0x00)
2347
68
              {
2348
68
                case 0x00:
2349
68
                  goto op_semantics_3;
2350
0
                  break;
2351
68
              }
2352
0
            break;
2353
116
          case 0x8b:
2354
116
              GETBYTE ();
2355
116
              switch (op[2] & 0x00)
2356
116
              {
2357
116
                case 0x00:
2358
116
                  goto op_semantics_3;
2359
0
                  break;
2360
116
              }
2361
0
            break;
2362
577
          case 0x8c:
2363
577
              GETBYTE ();
2364
577
              switch (op[2] & 0x00)
2365
577
              {
2366
577
                case 0x00:
2367
577
                  goto op_semantics_4;
2368
0
                  break;
2369
577
              }
2370
0
            break;
2371
940
          case 0x8d:
2372
940
              GETBYTE ();
2373
940
              switch (op[2] & 0x00)
2374
940
              {
2375
940
                case 0x00:
2376
940
                  goto op_semantics_4;
2377
0
                  break;
2378
940
              }
2379
0
            break;
2380
79
          case 0x8e:
2381
79
              GETBYTE ();
2382
79
              switch (op[2] & 0x00)
2383
79
              {
2384
79
                case 0x00:
2385
79
                  goto op_semantics_4;
2386
0
                  break;
2387
79
              }
2388
0
            break;
2389
283
          case 0x8f:
2390
283
              GETBYTE ();
2391
283
              switch (op[2] & 0x00)
2392
283
              {
2393
277
                case 0x00:
2394
277
                  goto op_semantics_4;
2395
0
                  break;
2396
283
              }
2397
0
            break;
2398
443
          case 0x90:
2399
443
              GETBYTE ();
2400
443
              switch (op[2] & 0x00)
2401
443
              {
2402
443
                case 0x00:
2403
443
                  goto op_semantics_5;
2404
0
                  break;
2405
443
              }
2406
0
            break;
2407
59
          case 0x91:
2408
59
              GETBYTE ();
2409
59
              switch (op[2] & 0x00)
2410
59
              {
2411
59
                case 0x00:
2412
59
                  goto op_semantics_5;
2413
0
                  break;
2414
59
              }
2415
0
            break;
2416
245
          case 0x92:
2417
245
              GETBYTE ();
2418
245
              switch (op[2] & 0x00)
2419
245
              {
2420
245
                case 0x00:
2421
245
                  goto op_semantics_5;
2422
0
                  break;
2423
245
              }
2424
0
            break;
2425
75
          case 0x93:
2426
75
              GETBYTE ();
2427
75
              switch (op[2] & 0x00)
2428
75
              {
2429
75
                case 0x00:
2430
75
                  goto op_semantics_5;
2431
0
                  break;
2432
75
              }
2433
0
            break;
2434
39
          case 0x94:
2435
39
              GETBYTE ();
2436
39
              switch (op[2] & 0x00)
2437
39
              {
2438
38
                case 0x00:
2439
38
                  goto op_semantics_6;
2440
0
                  break;
2441
39
              }
2442
0
            break;
2443
20
          case 0x95:
2444
20
              GETBYTE ();
2445
20
              switch (op[2] & 0x00)
2446
20
              {
2447
20
                case 0x00:
2448
20
                  goto op_semantics_6;
2449
0
                  break;
2450
20
              }
2451
0
            break;
2452
146
          case 0x96:
2453
146
              GETBYTE ();
2454
146
              switch (op[2] & 0x00)
2455
146
              {
2456
146
                case 0x00:
2457
146
                  goto op_semantics_6;
2458
0
                  break;
2459
146
              }
2460
0
            break;
2461
162
          case 0x97:
2462
162
              GETBYTE ();
2463
162
              switch (op[2] & 0x00)
2464
162
              {
2465
162
                case 0x00:
2466
162
                  goto op_semantics_6;
2467
0
                  break;
2468
162
              }
2469
0
            break;
2470
1.59k
          case 0xa0:
2471
1.59k
              GETBYTE ();
2472
1.59k
              switch (op[2] & 0xff)
2473
1.59k
              {
2474
111
                case 0x00:
2475
111
                    GETBYTE ();
2476
111
                    switch (op[3] & 0x00)
2477
111
                    {
2478
111
                      case 0x00:
2479
111
                        goto op_semantics_7;
2480
0
                        break;
2481
111
                    }
2482
0
                  break;
2483
77
                case 0x02:
2484
77
                    GETBYTE ();
2485
77
                    switch (op[3] & 0x00)
2486
77
                    {
2487
77
                      case 0x00:
2488
157
                        op_semantics_19:
2489
157
                          {
2490
                            /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2491
157
#line 519 "rx-decode.opc"
2492
157
                            int ss AU = op[1] & 0x03;
2493
157
#line 519 "rx-decode.opc"
2494
157
                            int rsrc AU = (op[3] >> 4) & 0x0f;
2495
157
#line 519 "rx-decode.opc"
2496
157
                            int rdst AU = op[3] & 0x0f;
2497
157
                            if (trace)
2498
0
                              {
2499
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2500
0
                                       "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */",
2501
0
                                       op[0], op[1], op[2], op[3]);
2502
0
                                printf ("  ss = 0x%x,", ss);
2503
0
                                printf ("  rsrc = 0x%x,", rsrc);
2504
0
                                printf ("  rdst = 0x%x\n", rdst);
2505
0
                              }
2506
157
                            SYNTAX("adc %1%S1, %0");
2507
157
#line 519 "rx-decode.opc"
2508
157
                            ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2509
2510
                          /*----------------------------------------------------------------------*/
2511
                          /* ADD                  */
2512
2513
157
                          }
2514
157
                        break;
2515
77
                    }
2516
157
                  break;
2517
157
                case 0x04:
2518
5
                    GETBYTE ();
2519
5
                    switch (op[3] & 0x00)
2520
5
                    {
2521
5
                      case 0x00:
2522
5
                        goto op_semantics_8;
2523
0
                        break;
2524
5
                    }
2525
0
                  break;
2526
49
                case 0x05:
2527
49
                    GETBYTE ();
2528
49
                    switch (op[3] & 0x00)
2529
49
                    {
2530
49
                      case 0x00:
2531
49
                        goto op_semantics_9;
2532
0
                        break;
2533
49
                    }
2534
0
                  break;
2535
245
                case 0x06:
2536
245
                    GETBYTE ();
2537
245
                    switch (op[3] & 0x00)
2538
245
                    {
2539
245
                      case 0x00:
2540
245
                        goto op_semantics_10;
2541
0
                        break;
2542
245
                    }
2543
0
                  break;
2544
55
                case 0x07:
2545
55
                    GETBYTE ();
2546
55
                    switch (op[3] & 0x00)
2547
55
                    {
2548
55
                      case 0x00:
2549
55
                        goto op_semantics_11;
2550
0
                        break;
2551
55
                    }
2552
0
                  break;
2553
71
                case 0x08:
2554
71
                    GETBYTE ();
2555
71
                    switch (op[3] & 0x00)
2556
71
                    {
2557
71
                      case 0x00:
2558
71
                        goto op_semantics_12;
2559
0
                        break;
2560
71
                    }
2561
0
                  break;
2562
127
                case 0x09:
2563
127
                    GETBYTE ();
2564
127
                    switch (op[3] & 0x00)
2565
127
                    {
2566
127
                      case 0x00:
2567
127
                        goto op_semantics_13;
2568
0
                        break;
2569
127
                    }
2570
0
                  break;
2571
40
                case 0x0c:
2572
40
                    GETBYTE ();
2573
40
                    switch (op[3] & 0x00)
2574
40
                    {
2575
40
                      case 0x00:
2576
40
                        goto op_semantics_14;
2577
0
                        break;
2578
40
                    }
2579
0
                  break;
2580
39
                case 0x0d:
2581
39
                    GETBYTE ();
2582
39
                    switch (op[3] & 0x00)
2583
39
                    {
2584
39
                      case 0x00:
2585
39
                        goto op_semantics_15;
2586
0
                        break;
2587
39
                    }
2588
0
                  break;
2589
88
                case 0x10:
2590
88
                    GETBYTE ();
2591
88
                    switch (op[3] & 0x00)
2592
88
                    {
2593
88
                      case 0x00:
2594
88
                        goto op_semantics_16;
2595
0
                        break;
2596
88
                    }
2597
0
                  break;
2598
217
                case 0x11:
2599
217
                    GETBYTE ();
2600
217
                    switch (op[3] & 0x00)
2601
217
                    {
2602
217
                      case 0x00:
2603
217
                        goto op_semantics_17;
2604
0
                        break;
2605
217
                    }
2606
0
                  break;
2607
54
                case 0x15:
2608
54
                    GETBYTE ();
2609
54
                    switch (op[3] & 0x00)
2610
54
                    {
2611
54
                      case 0x00:
2612
54
                        goto op_semantics_18;
2613
0
                        break;
2614
54
                    }
2615
0
                  break;
2616
420
                default: UNSUPPORTED(); break;
2617
1.59k
              }
2618
577
            break;
2619
795
          case 0xa1:
2620
795
              GETBYTE ();
2621
795
              switch (op[2] & 0xff)
2622
795
              {
2623
97
                case 0x00:
2624
97
                    GETBYTE ();
2625
97
                    switch (op[3] & 0x00)
2626
97
                    {
2627
97
                      case 0x00:
2628
97
                        goto op_semantics_7;
2629
0
                        break;
2630
97
                    }
2631
0
                  break;
2632
65
                case 0x02:
2633
65
                    GETBYTE ();
2634
65
                    switch (op[3] & 0x00)
2635
65
                    {
2636
65
                      case 0x00:
2637
65
                        goto op_semantics_19;
2638
0
                        break;
2639
65
                    }
2640
0
                  break;
2641
151
                case 0x04:
2642
151
                    GETBYTE ();
2643
151
                    switch (op[3] & 0x00)
2644
151
                    {
2645
151
                      case 0x00:
2646
151
                        goto op_semantics_8;
2647
0
                        break;
2648
151
                    }
2649
0
                  break;
2650
37
                case 0x05:
2651
37
                    GETBYTE ();
2652
37
                    switch (op[3] & 0x00)
2653
37
                    {
2654
37
                      case 0x00:
2655
37
                        goto op_semantics_9;
2656
0
                        break;
2657
37
                    }
2658
0
                  break;
2659
43
                case 0x06:
2660
43
                    GETBYTE ();
2661
43
                    switch (op[3] & 0x00)
2662
43
                    {
2663
43
                      case 0x00:
2664
43
                        goto op_semantics_10;
2665
0
                        break;
2666
43
                    }
2667
0
                  break;
2668
10
                case 0x07:
2669
10
                    GETBYTE ();
2670
10
                    switch (op[3] & 0x00)
2671
10
                    {
2672
10
                      case 0x00:
2673
10
                        goto op_semantics_11;
2674
0
                        break;
2675
10
                    }
2676
0
                  break;
2677
0
                case 0x08:
2678
0
                    GETBYTE ();
2679
0
                    switch (op[3] & 0x00)
2680
0
                    {
2681
0
                      case 0x00:
2682
0
                        goto op_semantics_12;
2683
0
                        break;
2684
0
                    }
2685
0
                  break;
2686
13
                case 0x09:
2687
13
                    GETBYTE ();
2688
13
                    switch (op[3] & 0x00)
2689
13
                    {
2690
13
                      case 0x00:
2691
13
                        goto op_semantics_13;
2692
0
                        break;
2693
13
                    }
2694
0
                  break;
2695
0
                case 0x0c:
2696
0
                    GETBYTE ();
2697
0
                    switch (op[3] & 0x00)
2698
0
                    {
2699
0
                      case 0x00:
2700
0
                        goto op_semantics_14;
2701
0
                        break;
2702
0
                    }
2703
0
                  break;
2704
6
                case 0x0d:
2705
6
                    GETBYTE ();
2706
6
                    switch (op[3] & 0x00)
2707
6
                    {
2708
6
                      case 0x00:
2709
6
                        goto op_semantics_15;
2710
0
                        break;
2711
6
                    }
2712
0
                  break;
2713
77
                case 0x10:
2714
77
                    GETBYTE ();
2715
77
                    switch (op[3] & 0x00)
2716
77
                    {
2717
77
                      case 0x00:
2718
77
                        goto op_semantics_16;
2719
0
                        break;
2720
77
                    }
2721
0
                  break;
2722
60
                case 0x11:
2723
60
                    GETBYTE ();
2724
60
                    switch (op[3] & 0x00)
2725
60
                    {
2726
60
                      case 0x00:
2727
60
                        goto op_semantics_17;
2728
0
                        break;
2729
60
                    }
2730
0
                  break;
2731
59
                case 0x15:
2732
59
                    GETBYTE ();
2733
59
                    switch (op[3] & 0x00)
2734
59
                    {
2735
59
                      case 0x00:
2736
59
                        goto op_semantics_18;
2737
0
                        break;
2738
59
                    }
2739
0
                  break;
2740
177
                default: UNSUPPORTED(); break;
2741
795
              }
2742
177
            break;
2743
861
          case 0xa2:
2744
861
              GETBYTE ();
2745
861
              switch (op[2] & 0xff)
2746
861
              {
2747
19
                case 0x00:
2748
19
                    GETBYTE ();
2749
19
                    switch (op[3] & 0x00)
2750
19
                    {
2751
18
                      case 0x00:
2752
18
                        goto op_semantics_7;
2753
0
                        break;
2754
19
                    }
2755
0
                  break;
2756
10
                case 0x02:
2757
10
                    GETBYTE ();
2758
10
                    switch (op[3] & 0x00)
2759
10
                    {
2760
10
                      case 0x00:
2761
10
                        goto op_semantics_19;
2762
0
                        break;
2763
10
                    }
2764
0
                  break;
2765
82
                case 0x04:
2766
82
                    GETBYTE ();
2767
82
                    switch (op[3] & 0x00)
2768
82
                    {
2769
82
                      case 0x00:
2770
82
                        goto op_semantics_8;
2771
0
                        break;
2772
82
                    }
2773
0
                  break;
2774
38
                case 0x05:
2775
38
                    GETBYTE ();
2776
38
                    switch (op[3] & 0x00)
2777
38
                    {
2778
38
                      case 0x00:
2779
38
                        goto op_semantics_9;
2780
0
                        break;
2781
38
                    }
2782
0
                  break;
2783
180
                case 0x06:
2784
180
                    GETBYTE ();
2785
180
                    switch (op[3] & 0x00)
2786
180
                    {
2787
180
                      case 0x00:
2788
180
                        goto op_semantics_10;
2789
0
                        break;
2790
180
                    }
2791
0
                  break;
2792
84
                case 0x07:
2793
84
                    GETBYTE ();
2794
84
                    switch (op[3] & 0x00)
2795
84
                    {
2796
84
                      case 0x00:
2797
84
                        goto op_semantics_11;
2798
0
                        break;
2799
84
                    }
2800
0
                  break;
2801
144
                case 0x08:
2802
144
                    GETBYTE ();
2803
144
                    switch (op[3] & 0x00)
2804
144
                    {
2805
144
                      case 0x00:
2806
144
                        goto op_semantics_12;
2807
0
                        break;
2808
144
                    }
2809
0
                  break;
2810
73
                case 0x09:
2811
73
                    GETBYTE ();
2812
73
                    switch (op[3] & 0x00)
2813
73
                    {
2814
73
                      case 0x00:
2815
73
                        goto op_semantics_13;
2816
0
                        break;
2817
73
                    }
2818
0
                  break;
2819
3
                case 0x0c:
2820
3
                    GETBYTE ();
2821
3
                    switch (op[3] & 0x00)
2822
3
                    {
2823
3
                      case 0x00:
2824
3
                        goto op_semantics_14;
2825
0
                        break;
2826
3
                    }
2827
0
                  break;
2828
0
                case 0x0d:
2829
0
                    GETBYTE ();
2830
0
                    switch (op[3] & 0x00)
2831
0
                    {
2832
0
                      case 0x00:
2833
0
                        goto op_semantics_15;
2834
0
                        break;
2835
0
                    }
2836
0
                  break;
2837
20
                case 0x10:
2838
20
                    GETBYTE ();
2839
20
                    switch (op[3] & 0x00)
2840
20
                    {
2841
20
                      case 0x00:
2842
20
                        goto op_semantics_16;
2843
0
                        break;
2844
20
                    }
2845
0
                  break;
2846
41
                case 0x11:
2847
41
                    GETBYTE ();
2848
41
                    switch (op[3] & 0x00)
2849
41
                    {
2850
41
                      case 0x00:
2851
41
                        goto op_semantics_17;
2852
0
                        break;
2853
41
                    }
2854
0
                  break;
2855
3
                case 0x15:
2856
3
                    GETBYTE ();
2857
3
                    switch (op[3] & 0x00)
2858
3
                    {
2859
3
                      case 0x00:
2860
3
                        goto op_semantics_18;
2861
0
                        break;
2862
3
                    }
2863
0
                  break;
2864
164
                default: UNSUPPORTED(); break;
2865
861
              }
2866
164
            break;
2867
547
          case 0xa3:
2868
547
              GETBYTE ();
2869
547
              switch (op[2] & 0xff)
2870
547
              {
2871
11
                case 0x00:
2872
11
                    GETBYTE ();
2873
11
                    switch (op[3] & 0x00)
2874
11
                    {
2875
11
                      case 0x00:
2876
11
                        goto op_semantics_7;
2877
0
                        break;
2878
11
                    }
2879
0
                  break;
2880
5
                case 0x02:
2881
5
                    GETBYTE ();
2882
5
                    switch (op[3] & 0x00)
2883
5
                    {
2884
5
                      case 0x00:
2885
5
                        goto op_semantics_19;
2886
0
                        break;
2887
5
                    }
2888
0
                  break;
2889
84
                case 0x04:
2890
84
                    GETBYTE ();
2891
84
                    switch (op[3] & 0x00)
2892
84
                    {
2893
84
                      case 0x00:
2894
84
                        goto op_semantics_8;
2895
0
                        break;
2896
84
                    }
2897
0
                  break;
2898
0
                case 0x05:
2899
0
                    GETBYTE ();
2900
0
                    switch (op[3] & 0x00)
2901
0
                    {
2902
0
                      case 0x00:
2903
0
                        goto op_semantics_9;
2904
0
                        break;
2905
0
                    }
2906
0
                  break;
2907
67
                case 0x06:
2908
67
                    GETBYTE ();
2909
67
                    switch (op[3] & 0x00)
2910
67
                    {
2911
67
                      case 0x00:
2912
67
                        goto op_semantics_10;
2913
0
                        break;
2914
67
                    }
2915
0
                  break;
2916
26
                case 0x07:
2917
26
                    GETBYTE ();
2918
26
                    switch (op[3] & 0x00)
2919
26
                    {
2920
26
                      case 0x00:
2921
26
                        goto op_semantics_11;
2922
0
                        break;
2923
26
                    }
2924
0
                  break;
2925
0
                case 0x08:
2926
0
                    GETBYTE ();
2927
0
                    switch (op[3] & 0x00)
2928
0
                    {
2929
0
                      case 0x00:
2930
0
                        goto op_semantics_12;
2931
0
                        break;
2932
0
                    }
2933
0
                  break;
2934
33
                case 0x09:
2935
33
                    GETBYTE ();
2936
33
                    switch (op[3] & 0x00)
2937
33
                    {
2938
33
                      case 0x00:
2939
33
                        goto op_semantics_13;
2940
0
                        break;
2941
33
                    }
2942
0
                  break;
2943
156
                case 0x0c:
2944
156
                    GETBYTE ();
2945
156
                    switch (op[3] & 0x00)
2946
156
                    {
2947
156
                      case 0x00:
2948
156
                        goto op_semantics_14;
2949
0
                        break;
2950
156
                    }
2951
0
                  break;
2952
78
                case 0x0d:
2953
78
                    GETBYTE ();
2954
78
                    switch (op[3] & 0x00)
2955
78
                    {
2956
78
                      case 0x00:
2957
78
                        goto op_semantics_15;
2958
0
                        break;
2959
78
                    }
2960
0
                  break;
2961
20
                case 0x10:
2962
20
                    GETBYTE ();
2963
20
                    switch (op[3] & 0x00)
2964
20
                    {
2965
20
                      case 0x00:
2966
20
                        goto op_semantics_16;
2967
0
                        break;
2968
20
                    }
2969
0
                  break;
2970
15
                case 0x11:
2971
15
                    GETBYTE ();
2972
15
                    switch (op[3] & 0x00)
2973
15
                    {
2974
15
                      case 0x00:
2975
15
                        goto op_semantics_17;
2976
0
                        break;
2977
15
                    }
2978
0
                  break;
2979
4
                case 0x15:
2980
4
                    GETBYTE ();
2981
4
                    switch (op[3] & 0x00)
2982
4
                    {
2983
4
                      case 0x00:
2984
4
                        goto op_semantics_18;
2985
0
                        break;
2986
4
                    }
2987
0
                  break;
2988
48
                default: UNSUPPORTED(); break;
2989
547
              }
2990
48
            break;
2991
78
          case 0xc0:
2992
78
              GETBYTE ();
2993
78
              switch (op[2] & 0x00)
2994
78
              {
2995
78
                case 0x00:
2996
78
                  goto op_semantics_1;
2997
0
                  break;
2998
78
              }
2999
0
            break;
3000
60
          case 0xc1:
3001
60
              GETBYTE ();
3002
60
              switch (op[2] & 0x00)
3003
60
              {
3004
60
                case 0x00:
3005
60
                  goto op_semantics_1;
3006
0
                  break;
3007
60
              }
3008
0
            break;
3009
152
          case 0xc2:
3010
152
              GETBYTE ();
3011
152
              switch (op[2] & 0x00)
3012
152
              {
3013
151
                case 0x00:
3014
151
                  goto op_semantics_1;
3015
0
                  break;
3016
152
              }
3017
0
            break;
3018
203
          case 0xc3:
3019
203
              GETBYTE ();
3020
203
              switch (op[2] & 0x00)
3021
203
              {
3022
184
                case 0x00:
3023
184
                  goto op_semantics_1;
3024
0
                  break;
3025
203
              }
3026
0
            break;
3027
107
          case 0xc4:
3028
107
              GETBYTE ();
3029
107
              switch (op[2] & 0x00)
3030
107
              {
3031
107
                case 0x00:
3032
107
                  goto op_semantics_2;
3033
0
                  break;
3034
107
              }
3035
0
            break;
3036
167
          case 0xc5:
3037
167
              GETBYTE ();
3038
167
              switch (op[2] & 0x00)
3039
167
              {
3040
167
                case 0x00:
3041
167
                  goto op_semantics_2;
3042
0
                  break;
3043
167
              }
3044
0
            break;
3045
104
          case 0xc6:
3046
104
              GETBYTE ();
3047
104
              switch (op[2] & 0x00)
3048
104
              {
3049
97
                case 0x00:
3050
97
                  goto op_semantics_2;
3051
0
                  break;
3052
104
              }
3053
0
            break;
3054
32
          case 0xc7:
3055
32
              GETBYTE ();
3056
32
              switch (op[2] & 0x00)
3057
32
              {
3058
30
                case 0x00:
3059
30
                  goto op_semantics_2;
3060
0
                  break;
3061
32
              }
3062
0
            break;
3063
281
          case 0xc8:
3064
281
              GETBYTE ();
3065
281
              switch (op[2] & 0x00)
3066
281
              {
3067
281
                case 0x00:
3068
281
                  goto op_semantics_3;
3069
0
                  break;
3070
281
              }
3071
0
            break;
3072
10
          case 0xc9:
3073
10
              GETBYTE ();
3074
10
              switch (op[2] & 0x00)
3075
10
              {
3076
10
                case 0x00:
3077
10
                  goto op_semantics_3;
3078
0
                  break;
3079
10
              }
3080
0
            break;
3081
257
          case 0xca:
3082
257
              GETBYTE ();
3083
257
              switch (op[2] & 0x00)
3084
257
              {
3085
257
                case 0x00:
3086
257
                  goto op_semantics_3;
3087
0
                  break;
3088
257
              }
3089
0
            break;
3090
239
          case 0xcb:
3091
239
              GETBYTE ();
3092
239
              switch (op[2] & 0x00)
3093
239
              {
3094
239
                case 0x00:
3095
239
                  goto op_semantics_3;
3096
0
                  break;
3097
239
              }
3098
0
            break;
3099
143
          case 0xcc:
3100
143
              GETBYTE ();
3101
143
              switch (op[2] & 0x00)
3102
143
              {
3103
143
                case 0x00:
3104
143
                  goto op_semantics_4;
3105
0
                  break;
3106
143
              }
3107
0
            break;
3108
63
          case 0xcd:
3109
63
              GETBYTE ();
3110
63
              switch (op[2] & 0x00)
3111
63
              {
3112
63
                case 0x00:
3113
63
                  goto op_semantics_4;
3114
0
                  break;
3115
63
              }
3116
0
            break;
3117
2.02k
          case 0xce:
3118
2.02k
              GETBYTE ();
3119
2.02k
              switch (op[2] & 0x00)
3120
2.02k
              {
3121
2.02k
                case 0x00:
3122
2.02k
                  goto op_semantics_4;
3123
0
                  break;
3124
2.02k
              }
3125
0
            break;
3126
9
          case 0xcf:
3127
9
              GETBYTE ();
3128
9
              switch (op[2] & 0x00)
3129
9
              {
3130
9
                case 0x00:
3131
9
                  goto op_semantics_4;
3132
0
                  break;
3133
9
              }
3134
0
            break;
3135
99
          case 0xd0:
3136
99
              GETBYTE ();
3137
99
              switch (op[2] & 0x00)
3138
99
              {
3139
99
                case 0x00:
3140
99
                  goto op_semantics_5;
3141
0
                  break;
3142
99
              }
3143
0
            break;
3144
112
          case 0xd1:
3145
112
              GETBYTE ();
3146
112
              switch (op[2] & 0x00)
3147
112
              {
3148
112
                case 0x00:
3149
112
                  goto op_semantics_5;
3150
0
                  break;
3151
112
              }
3152
0
            break;
3153
87
          case 0xd2:
3154
87
              GETBYTE ();
3155
87
              switch (op[2] & 0x00)
3156
87
              {
3157
87
                case 0x00:
3158
87
                  goto op_semantics_5;
3159
0
                  break;
3160
87
              }
3161
0
            break;
3162
304
          case 0xd3:
3163
304
              GETBYTE ();
3164
304
              switch (op[2] & 0x00)
3165
304
              {
3166
304
                case 0x00:
3167
304
                  goto op_semantics_5;
3168
0
                  break;
3169
304
              }
3170
0
            break;
3171
222
          case 0xd4:
3172
222
              GETBYTE ();
3173
222
              switch (op[2] & 0x00)
3174
222
              {
3175
221
                case 0x00:
3176
221
                  goto op_semantics_6;
3177
0
                  break;
3178
222
              }
3179
0
            break;
3180
44
          case 0xd5:
3181
44
              GETBYTE ();
3182
44
              switch (op[2] & 0x00)
3183
44
              {
3184
44
                case 0x00:
3185
44
                  goto op_semantics_6;
3186
0
                  break;
3187
44
              }
3188
0
            break;
3189
262
          case 0xd6:
3190
262
              GETBYTE ();
3191
262
              switch (op[2] & 0x00)
3192
262
              {
3193
262
                case 0x00:
3194
262
                  goto op_semantics_6;
3195
0
                  break;
3196
262
              }
3197
0
            break;
3198
72
          case 0xd7:
3199
72
              GETBYTE ();
3200
72
              switch (op[2] & 0x00)
3201
72
              {
3202
72
                case 0x00:
3203
72
                  goto op_semantics_6;
3204
0
                  break;
3205
72
              }
3206
0
            break;
3207
774
          case 0xe0:
3208
774
              GETBYTE ();
3209
774
              switch (op[2] & 0xff)
3210
774
              {
3211
1
                case 0x00:
3212
1
                    GETBYTE ();
3213
1
                    switch (op[3] & 0x00)
3214
1
                    {
3215
1
                      case 0x00:
3216
1
                        goto op_semantics_7;
3217
0
                        break;
3218
1
                    }
3219
0
                  break;
3220
8
                case 0x04:
3221
8
                    GETBYTE ();
3222
8
                    switch (op[3] & 0x00)
3223
8
                    {
3224
8
                      case 0x00:
3225
8
                        goto op_semantics_8;
3226
0
                        break;
3227
8
                    }
3228
0
                  break;
3229
1
                case 0x05:
3230
1
                    GETBYTE ();
3231
1
                    switch (op[3] & 0x00)
3232
1
                    {
3233
1
                      case 0x00:
3234
1
                        goto op_semantics_9;
3235
0
                        break;
3236
1
                    }
3237
0
                  break;
3238
120
                case 0x06:
3239
120
                    GETBYTE ();
3240
120
                    switch (op[3] & 0x00)
3241
120
                    {
3242
120
                      case 0x00:
3243
120
                        goto op_semantics_10;
3244
0
                        break;
3245
120
                    }
3246
0
                  break;
3247
0
                case 0x07:
3248
0
                    GETBYTE ();
3249
0
                    switch (op[3] & 0x00)
3250
0
                    {
3251
0
                      case 0x00:
3252
0
                        goto op_semantics_11;
3253
0
                        break;
3254
0
                    }
3255
0
                  break;
3256
4
                case 0x08:
3257
4
                    GETBYTE ();
3258
4
                    switch (op[3] & 0x00)
3259
4
                    {
3260
4
                      case 0x00:
3261
4
                        goto op_semantics_12;
3262
0
                        break;
3263
4
                    }
3264
0
                  break;
3265
101
                case 0x09:
3266
101
                    GETBYTE ();
3267
101
                    switch (op[3] & 0x00)
3268
101
                    {
3269
101
                      case 0x00:
3270
101
                        goto op_semantics_13;
3271
0
                        break;
3272
101
                    }
3273
0
                  break;
3274
3
                case 0x0c:
3275
3
                    GETBYTE ();
3276
3
                    switch (op[3] & 0x00)
3277
3
                    {
3278
3
                      case 0x00:
3279
3
                        goto op_semantics_14;
3280
0
                        break;
3281
3
                    }
3282
0
                  break;
3283
0
                case 0x0d:
3284
0
                    GETBYTE ();
3285
0
                    switch (op[3] & 0x00)
3286
0
                    {
3287
0
                      case 0x00:
3288
0
                        goto op_semantics_15;
3289
0
                        break;
3290
0
                    }
3291
0
                  break;
3292
37
                case 0x10:
3293
37
                    GETBYTE ();
3294
37
                    switch (op[3] & 0x00)
3295
37
                    {
3296
37
                      case 0x00:
3297
37
                        goto op_semantics_16;
3298
0
                        break;
3299
37
                    }
3300
0
                  break;
3301
2
                case 0x11:
3302
2
                    GETBYTE ();
3303
2
                    switch (op[3] & 0x00)
3304
2
                    {
3305
2
                      case 0x00:
3306
2
                        goto op_semantics_17;
3307
0
                        break;
3308
2
                    }
3309
0
                  break;
3310
261
                case 0x15:
3311
261
                    GETBYTE ();
3312
261
                    switch (op[3] & 0x00)
3313
261
                    {
3314
261
                      case 0x00:
3315
261
                        goto op_semantics_18;
3316
0
                        break;
3317
261
                    }
3318
0
                  break;
3319
236
                default: UNSUPPORTED(); break;
3320
774
              }
3321
236
            break;
3322
4.16k
          case 0xe1:
3323
4.16k
              GETBYTE ();
3324
4.16k
              switch (op[2] & 0xff)
3325
4.16k
              {
3326
1.15k
                case 0x00:
3327
1.15k
                    GETBYTE ();
3328
1.15k
                    switch (op[3] & 0x00)
3329
1.15k
                    {
3330
1.15k
                      case 0x00:
3331
1.15k
                        goto op_semantics_7;
3332
0
                        break;
3333
1.15k
                    }
3334
0
                  break;
3335
199
                case 0x04:
3336
199
                    GETBYTE ();
3337
199
                    switch (op[3] & 0x00)
3338
199
                    {
3339
199
                      case 0x00:
3340
199
                        goto op_semantics_8;
3341
0
                        break;
3342
199
                    }
3343
0
                  break;
3344
1.88k
                case 0x05:
3345
1.88k
                    GETBYTE ();
3346
1.88k
                    switch (op[3] & 0x00)
3347
1.88k
                    {
3348
1.88k
                      case 0x00:
3349
1.88k
                        goto op_semantics_9;
3350
0
                        break;
3351
1.88k
                    }
3352
0
                  break;
3353
11
                case 0x06:
3354
11
                    GETBYTE ();
3355
11
                    switch (op[3] & 0x00)
3356
11
                    {
3357
11
                      case 0x00:
3358
11
                        goto op_semantics_10;
3359
0
                        break;
3360
11
                    }
3361
0
                  break;
3362
15
                case 0x07:
3363
15
                    GETBYTE ();
3364
15
                    switch (op[3] & 0x00)
3365
15
                    {
3366
15
                      case 0x00:
3367
15
                        goto op_semantics_11;
3368
0
                        break;
3369
15
                    }
3370
0
                  break;
3371
28
                case 0x08:
3372
28
                    GETBYTE ();
3373
28
                    switch (op[3] & 0x00)
3374
28
                    {
3375
28
                      case 0x00:
3376
28
                        goto op_semantics_12;
3377
0
                        break;
3378
28
                    }
3379
0
                  break;
3380
103
                case 0x09:
3381
103
                    GETBYTE ();
3382
103
                    switch (op[3] & 0x00)
3383
103
                    {
3384
103
                      case 0x00:
3385
103
                        goto op_semantics_13;
3386
0
                        break;
3387
103
                    }
3388
0
                  break;
3389
11
                case 0x0c:
3390
11
                    GETBYTE ();
3391
11
                    switch (op[3] & 0x00)
3392
11
                    {
3393
11
                      case 0x00:
3394
11
                        goto op_semantics_14;
3395
0
                        break;
3396
11
                    }
3397
0
                  break;
3398
13
                case 0x0d:
3399
13
                    GETBYTE ();
3400
13
                    switch (op[3] & 0x00)
3401
13
                    {
3402
13
                      case 0x00:
3403
13
                        goto op_semantics_15;
3404
0
                        break;
3405
13
                    }
3406
0
                  break;
3407
80
                case 0x10:
3408
80
                    GETBYTE ();
3409
80
                    switch (op[3] & 0x00)
3410
80
                    {
3411
80
                      case 0x00:
3412
80
                        goto op_semantics_16;
3413
0
                        break;
3414
80
                    }
3415
0
                  break;
3416
16
                case 0x11:
3417
16
                    GETBYTE ();
3418
16
                    switch (op[3] & 0x00)
3419
16
                    {
3420
16
                      case 0x00:
3421
16
                        goto op_semantics_17;
3422
0
                        break;
3423
16
                    }
3424
0
                  break;
3425
346
                case 0x15:
3426
346
                    GETBYTE ();
3427
346
                    switch (op[3] & 0x00)
3428
346
                    {
3429
331
                      case 0x00:
3430
331
                        goto op_semantics_18;
3431
0
                        break;
3432
346
                    }
3433
0
                  break;
3434
297
                default: UNSUPPORTED(); break;
3435
4.16k
              }
3436
297
            break;
3437
1.52k
          case 0xe2:
3438
1.52k
              GETBYTE ();
3439
1.52k
              switch (op[2] & 0xff)
3440
1.52k
              {
3441
393
                case 0x00:
3442
393
                    GETBYTE ();
3443
393
                    switch (op[3] & 0x00)
3444
393
                    {
3445
393
                      case 0x00:
3446
393
                        goto op_semantics_7;
3447
0
                        break;
3448
393
                    }
3449
0
                  break;
3450
124
                case 0x04:
3451
124
                    GETBYTE ();
3452
124
                    switch (op[3] & 0x00)
3453
124
                    {
3454
124
                      case 0x00:
3455
124
                        goto op_semantics_8;
3456
0
                        break;
3457
124
                    }
3458
0
                  break;
3459
73
                case 0x05:
3460
73
                    GETBYTE ();
3461
73
                    switch (op[3] & 0x00)
3462
73
                    {
3463
73
                      case 0x00:
3464
73
                        goto op_semantics_9;
3465
0
                        break;
3466
73
                    }
3467
0
                  break;
3468
10
                case 0x06:
3469
10
                    GETBYTE ();
3470
10
                    switch (op[3] & 0x00)
3471
10
                    {
3472
10
                      case 0x00:
3473
10
                        goto op_semantics_10;
3474
0
                        break;
3475
10
                    }
3476
0
                  break;
3477
72
                case 0x07:
3478
72
                    GETBYTE ();
3479
72
                    switch (op[3] & 0x00)
3480
72
                    {
3481
72
                      case 0x00:
3482
72
                        goto op_semantics_11;
3483
0
                        break;
3484
72
                    }
3485
0
                  break;
3486
1
                case 0x08:
3487
1
                    GETBYTE ();
3488
1
                    switch (op[3] & 0x00)
3489
1
                    {
3490
1
                      case 0x00:
3491
1
                        goto op_semantics_12;
3492
0
                        break;
3493
1
                    }
3494
0
                  break;
3495
3
                case 0x09:
3496
3
                    GETBYTE ();
3497
3
                    switch (op[3] & 0x00)
3498
3
                    {
3499
3
                      case 0x00:
3500
3
                        goto op_semantics_13;
3501
0
                        break;
3502
3
                    }
3503
0
                  break;
3504
2
                case 0x0c:
3505
2
                    GETBYTE ();
3506
2
                    switch (op[3] & 0x00)
3507
2
                    {
3508
2
                      case 0x00:
3509
2
                        goto op_semantics_14;
3510
0
                        break;
3511
2
                    }
3512
0
                  break;
3513
24
                case 0x0d:
3514
24
                    GETBYTE ();
3515
24
                    switch (op[3] & 0x00)
3516
24
                    {
3517
24
                      case 0x00:
3518
24
                        goto op_semantics_15;
3519
0
                        break;
3520
24
                    }
3521
0
                  break;
3522
20
                case 0x10:
3523
20
                    GETBYTE ();
3524
20
                    switch (op[3] & 0x00)
3525
20
                    {
3526
20
                      case 0x00:
3527
20
                        goto op_semantics_16;
3528
0
                        break;
3529
20
                    }
3530
0
                  break;
3531
322
                case 0x11:
3532
322
                    GETBYTE ();
3533
322
                    switch (op[3] & 0x00)
3534
322
                    {
3535
322
                      case 0x00:
3536
322
                        goto op_semantics_17;
3537
0
                        break;
3538
322
                    }
3539
0
                  break;
3540
8
                case 0x15:
3541
8
                    GETBYTE ();
3542
8
                    switch (op[3] & 0x00)
3543
8
                    {
3544
8
                      case 0x00:
3545
8
                        goto op_semantics_18;
3546
0
                        break;
3547
8
                    }
3548
0
                  break;
3549
476
                default: UNSUPPORTED(); break;
3550
1.52k
              }
3551
476
            break;
3552
1.25k
          case 0xe3:
3553
1.25k
              GETBYTE ();
3554
1.25k
              switch (op[2] & 0xff)
3555
1.25k
              {
3556
22
                case 0x00:
3557
22
                    GETBYTE ();
3558
22
                    switch (op[3] & 0x00)
3559
22
                    {
3560
22
                      case 0x00:
3561
22
                        goto op_semantics_7;
3562
0
                        break;
3563
22
                    }
3564
0
                  break;
3565
230
                case 0x04:
3566
230
                    GETBYTE ();
3567
230
                    switch (op[3] & 0x00)
3568
230
                    {
3569
230
                      case 0x00:
3570
230
                        goto op_semantics_8;
3571
0
                        break;
3572
230
                    }
3573
0
                  break;
3574
9
                case 0x05:
3575
9
                    GETBYTE ();
3576
9
                    switch (op[3] & 0x00)
3577
9
                    {
3578
9
                      case 0x00:
3579
9
                        goto op_semantics_9;
3580
0
                        break;
3581
9
                    }
3582
0
                  break;
3583
8
                case 0x06:
3584
8
                    GETBYTE ();
3585
8
                    switch (op[3] & 0x00)
3586
8
                    {
3587
8
                      case 0x00:
3588
8
                        goto op_semantics_10;
3589
0
                        break;
3590
8
                    }
3591
0
                  break;
3592
31
                case 0x07:
3593
31
                    GETBYTE ();
3594
31
                    switch (op[3] & 0x00)
3595
31
                    {
3596
31
                      case 0x00:
3597
31
                        goto op_semantics_11;
3598
0
                        break;
3599
31
                    }
3600
0
                  break;
3601
146
                case 0x08:
3602
146
                    GETBYTE ();
3603
146
                    switch (op[3] & 0x00)
3604
146
                    {
3605
146
                      case 0x00:
3606
146
                        goto op_semantics_12;
3607
0
                        break;
3608
146
                    }
3609
0
                  break;
3610
25
                case 0x09:
3611
25
                    GETBYTE ();
3612
25
                    switch (op[3] & 0x00)
3613
25
                    {
3614
7
                      case 0x00:
3615
7
                        goto op_semantics_13;
3616
0
                        break;
3617
25
                    }
3618
0
                  break;
3619
305
                case 0x0c:
3620
305
                    GETBYTE ();
3621
305
                    switch (op[3] & 0x00)
3622
305
                    {
3623
305
                      case 0x00:
3624
305
                        goto op_semantics_14;
3625
0
                        break;
3626
305
                    }
3627
0
                  break;
3628
23
                case 0x0d:
3629
23
                    GETBYTE ();
3630
23
                    switch (op[3] & 0x00)
3631
23
                    {
3632
23
                      case 0x00:
3633
23
                        goto op_semantics_15;
3634
0
                        break;
3635
23
                    }
3636
0
                  break;
3637
192
                case 0x10:
3638
192
                    GETBYTE ();
3639
192
                    switch (op[3] & 0x00)
3640
192
                    {
3641
192
                      case 0x00:
3642
192
                        goto op_semantics_16;
3643
0
                        break;
3644
192
                    }
3645
0
                  break;
3646
20
                case 0x11:
3647
20
                    GETBYTE ();
3648
20
                    switch (op[3] & 0x00)
3649
20
                    {
3650
20
                      case 0x00:
3651
20
                        goto op_semantics_17;
3652
0
                        break;
3653
20
                    }
3654
0
                  break;
3655
42
                case 0x15:
3656
42
                    GETBYTE ();
3657
42
                    switch (op[3] & 0x00)
3658
42
                    {
3659
42
                      case 0x00:
3660
42
                        goto op_semantics_18;
3661
0
                        break;
3662
42
                    }
3663
0
                  break;
3664
203
                default: UNSUPPORTED(); break;
3665
1.25k
              }
3666
203
            break;
3667
22.1k
          default: UNSUPPORTED(); break;
3668
91.8k
        }
3669
91.7k
      break;
3670
91.7k
    case 0x08:
3671
133k
    case 0x09:
3672
185k
    case 0x0a:
3673
236k
    case 0x0b:
3674
290k
    case 0x0c:
3675
351k
    case 0x0d:
3676
399k
    case 0x0e:
3677
449k
    case 0x0f:
3678
449k
        {
3679
          /** 0000 1dsp     bra.s %a0 */
3680
449k
#line 800 "rx-decode.opc"
3681
449k
          int dsp AU = op[0] & 0x07;
3682
449k
          if (trace)
3683
0
            {
3684
0
              printf ("\033[33m%s\033[0m  %02x\n",
3685
0
                     "/** 0000 1dsp     bra.s %a0 */",
3686
0
                     op[0]);
3687
0
              printf ("  dsp = 0x%x\n", dsp);
3688
0
            }
3689
449k
          SYNTAX("bra.s %a0");
3690
449k
#line 800 "rx-decode.opc"
3691
449k
          ID(branch); DC(pc + dsp3map[dsp]);
3692
3693
449k
        }
3694
449k
      break;
3695
116k
    case 0x10:
3696
179k
    case 0x11:
3697
218k
    case 0x12:
3698
270k
    case 0x13:
3699
311k
    case 0x14:
3700
345k
    case 0x15:
3701
382k
    case 0x16:
3702
408k
    case 0x17:
3703
454k
    case 0x18:
3704
492k
    case 0x19:
3705
522k
    case 0x1a:
3706
563k
    case 0x1b:
3707
615k
    case 0x1c:
3708
645k
    case 0x1d:
3709
673k
    case 0x1e:
3710
710k
    case 0x1f:
3711
710k
        {
3712
          /** 0001 n dsp      b%1.s %a0 */
3713
710k
#line 790 "rx-decode.opc"
3714
710k
          int n AU = (op[0] >> 3) & 0x01;
3715
710k
#line 790 "rx-decode.opc"
3716
710k
          int dsp AU = op[0] & 0x07;
3717
710k
          if (trace)
3718
0
            {
3719
0
              printf ("\033[33m%s\033[0m  %02x\n",
3720
0
                     "/** 0001 n dsp      b%1.s %a0 */",
3721
0
                     op[0]);
3722
0
              printf ("  n = 0x%x,", n);
3723
0
              printf ("  dsp = 0x%x\n", dsp);
3724
0
            }
3725
710k
          SYNTAX("b%1.s %a0");
3726
710k
#line 790 "rx-decode.opc"
3727
710k
          ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3728
3729
710k
        }
3730
710k
      break;
3731
105k
    case 0x20:
3732
140k
    case 0x21:
3733
169k
    case 0x22:
3734
200k
    case 0x23:
3735
245k
    case 0x24:
3736
282k
    case 0x25:
3737
315k
    case 0x26:
3738
336k
    case 0x27:
3739
374k
    case 0x28:
3740
398k
    case 0x29:
3741
425k
    case 0x2a:
3742
456k
    case 0x2b:
3743
481k
    case 0x2c:
3744
514k
    case 0x2d:
3745
544k
    case 0x2f:
3746
544k
        {
3747
          /** 0010 cond     b%1.b %a0 */
3748
544k
#line 793 "rx-decode.opc"
3749
544k
          int cond AU = op[0] & 0x0f;
3750
544k
          if (trace)
3751
0
            {
3752
0
              printf ("\033[33m%s\033[0m  %02x\n",
3753
0
                     "/** 0010 cond     b%1.b %a0 */",
3754
0
                     op[0]);
3755
0
              printf ("  cond = 0x%x\n", cond);
3756
0
            }
3757
544k
          SYNTAX("b%1.b %a0");
3758
544k
#line 793 "rx-decode.opc"
3759
544k
          ID(branch); Scc(cond); DC(pc + IMMex (1));
3760
3761
544k
        }
3762
544k
      break;
3763
47.9k
    case 0x2e:
3764
47.9k
        {
3765
          /** 0010 1110     bra.b %a0 */
3766
47.9k
          if (trace)
3767
0
            {
3768
0
              printf ("\033[33m%s\033[0m  %02x\n",
3769
0
                     "/** 0010 1110     bra.b %a0 */",
3770
0
                     op[0]);
3771
0
            }
3772
47.9k
          SYNTAX("bra.b %a0");
3773
47.9k
#line 803 "rx-decode.opc"
3774
47.9k
          ID(branch); DC(pc + IMMex(1));
3775
3776
47.9k
        }
3777
47.9k
      break;
3778
57.7k
    case 0x38:
3779
57.7k
        {
3780
          /** 0011 1000     bra.w %a0 */
3781
57.7k
          if (trace)
3782
0
            {
3783
0
              printf ("\033[33m%s\033[0m  %02x\n",
3784
0
                     "/** 0011 1000     bra.w %a0 */",
3785
0
                     op[0]);
3786
0
            }
3787
57.7k
          SYNTAX("bra.w %a0");
3788
57.7k
#line 806 "rx-decode.opc"
3789
57.7k
          ID(branch); DC(pc + IMMex(2));
3790
3791
57.7k
        }
3792
57.7k
      break;
3793
45.4k
    case 0x39:
3794
45.4k
        {
3795
          /** 0011 1001     bsr.w %a0 */
3796
45.4k
          if (trace)
3797
0
            {
3798
0
              printf ("\033[33m%s\033[0m  %02x\n",
3799
0
                     "/** 0011 1001     bsr.w %a0 */",
3800
0
                     op[0]);
3801
0
            }
3802
45.4k
          SYNTAX("bsr.w %a0");
3803
45.4k
#line 822 "rx-decode.opc"
3804
45.4k
          ID(jsr); DC(pc + IMMex(2));
3805
3806
45.4k
        }
3807
45.4k
      break;
3808
28.8k
    case 0x3a:
3809
51.3k
    case 0x3b:
3810
51.3k
        {
3811
          /** 0011 101c     b%1.w %a0 */
3812
51.3k
#line 796 "rx-decode.opc"
3813
51.3k
          int c AU = op[0] & 0x01;
3814
51.3k
          if (trace)
3815
0
            {
3816
0
              printf ("\033[33m%s\033[0m  %02x\n",
3817
0
                     "/** 0011 101c     b%1.w %a0 */",
3818
0
                     op[0]);
3819
0
              printf ("  c = 0x%x\n", c);
3820
0
            }
3821
51.3k
          SYNTAX("b%1.w %a0");
3822
51.3k
#line 796 "rx-decode.opc"
3823
51.3k
          ID(branch); Scc(c); DC(pc + IMMex (2));
3824
3825
3826
51.3k
        }
3827
51.3k
      break;
3828
22.8k
    case 0x3c:
3829
22.8k
        GETBYTE ();
3830
22.8k
        switch (op[1] & 0x00)
3831
22.8k
        {
3832
22.8k
          case 0x00:
3833
73.9k
            op_semantics_20:
3834
73.9k
              {
3835
                /** 0011 11sz d dst sppp    mov%s #%1, %0 */
3836
73.9k
#line 332 "rx-decode.opc"
3837
73.9k
                int sz AU = op[0] & 0x03;
3838
73.9k
#line 332 "rx-decode.opc"
3839
73.9k
                int d AU = (op[1] >> 7) & 0x01;
3840
73.9k
#line 332 "rx-decode.opc"
3841
73.9k
                int dst AU = (op[1] >> 4) & 0x07;
3842
73.9k
#line 332 "rx-decode.opc"
3843
73.9k
                int sppp AU = op[1] & 0x0f;
3844
73.9k
                if (trace)
3845
0
                  {
3846
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3847
0
                           "/** 0011 11sz d dst sppp    mov%s #%1, %0 */",
3848
0
                           op[0], op[1]);
3849
0
                    printf ("  sz = 0x%x,", sz);
3850
0
                    printf ("  d = 0x%x,", d);
3851
0
                    printf ("  dst = 0x%x,", dst);
3852
0
                    printf ("  sppp = 0x%x\n", sppp);
3853
0
                  }
3854
73.9k
                SYNTAX("mov%s #%1, %0");
3855
73.9k
#line 332 "rx-decode.opc"
3856
73.9k
                ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3857
3858
73.9k
              }
3859
73.9k
            break;
3860
22.8k
        }
3861
73.9k
      break;
3862
73.9k
    case 0x3d:
3863
23.5k
        GETBYTE ();
3864
23.5k
        switch (op[1] & 0x00)
3865
23.5k
        {
3866
23.5k
          case 0x00:
3867
23.5k
            goto op_semantics_20;
3868
0
            break;
3869
23.5k
        }
3870
0
      break;
3871
27.4k
    case 0x3e:
3872
27.4k
        GETBYTE ();
3873
27.4k
        switch (op[1] & 0x00)
3874
27.4k
        {
3875
27.4k
          case 0x00:
3876
27.4k
            goto op_semantics_20;
3877
0
            break;
3878
27.4k
        }
3879
0
      break;
3880
26.1k
    case 0x3f:
3881
26.1k
        GETBYTE ();
3882
26.1k
        switch (op[1] & 0x00)
3883
26.1k
        {
3884
26.1k
          case 0x00:
3885
26.1k
              {
3886
                /** 0011 1111 rega regb   rtsd  #%1, %2-%0 */
3887
26.1k
#line 429 "rx-decode.opc"
3888
26.1k
                int rega AU = (op[1] >> 4) & 0x0f;
3889
26.1k
#line 429 "rx-decode.opc"
3890
26.1k
                int regb AU = op[1] & 0x0f;
3891
26.1k
                if (trace)
3892
0
                  {
3893
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3894
0
                           "/** 0011 1111 rega regb   rtsd  #%1, %2-%0 */",
3895
0
                           op[0], op[1]);
3896
0
                    printf ("  rega = 0x%x,", rega);
3897
0
                    printf ("  regb = 0x%x\n", regb);
3898
0
                  }
3899
26.1k
                SYNTAX("rtsd  #%1, %2-%0");
3900
26.1k
#line 429 "rx-decode.opc"
3901
26.1k
                ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3902
3903
              /*----------------------------------------------------------------------*/
3904
              /* AND                  */
3905
3906
26.1k
              }
3907
26.1k
            break;
3908
26.1k
        }
3909
26.1k
      break;
3910
75.5k
    case 0x40:
3911
75.5k
        GETBYTE ();
3912
75.5k
        switch (op[1] & 0x00)
3913
75.5k
        {
3914
75.5k
          case 0x00:
3915
193k
            op_semantics_21:
3916
193k
              {
3917
                /** 0100 00ss rsrc rdst     sub %2%S2, %1 */
3918
193k
#line 564 "rx-decode.opc"
3919
193k
                int ss AU = op[0] & 0x03;
3920
193k
#line 564 "rx-decode.opc"
3921
193k
                int rsrc AU = (op[1] >> 4) & 0x0f;
3922
193k
#line 564 "rx-decode.opc"
3923
193k
                int rdst AU = op[1] & 0x0f;
3924
193k
                if (trace)
3925
0
                  {
3926
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3927
0
                           "/** 0100 00ss rsrc rdst     sub %2%S2, %1 */",
3928
0
                           op[0], op[1]);
3929
0
                    printf ("  ss = 0x%x,", ss);
3930
0
                    printf ("  rsrc = 0x%x,", rsrc);
3931
0
                    printf ("  rdst = 0x%x\n", rdst);
3932
0
                  }
3933
193k
                SYNTAX("sub %2%S2, %1");
3934
193k
#line 564 "rx-decode.opc"
3935
193k
                ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3936
3937
193k
              }
3938
193k
            break;
3939
75.5k
        }
3940
193k
      break;
3941
193k
    case 0x41:
3942
49.8k
        GETBYTE ();
3943
49.8k
        switch (op[1] & 0x00)
3944
49.8k
        {
3945
49.8k
          case 0x00:
3946
49.8k
            goto op_semantics_21;
3947
0
            break;
3948
49.8k
        }
3949
0
      break;
3950
47.7k
    case 0x42:
3951
47.7k
        GETBYTE ();
3952
47.7k
        switch (op[1] & 0x00)
3953
47.7k
        {
3954
47.7k
          case 0x00:
3955
47.7k
            goto op_semantics_21;
3956
0
            break;
3957
47.7k
        }
3958
0
      break;
3959
20.2k
    case 0x43:
3960
20.2k
        GETBYTE ();
3961
20.2k
        switch (op[1] & 0x00)
3962
20.2k
        {
3963
20.2k
          case 0x00:
3964
20.2k
            goto op_semantics_21;
3965
0
            break;
3966
20.2k
        }
3967
0
      break;
3968
48.2k
    case 0x44:
3969
48.2k
        GETBYTE ();
3970
48.2k
        switch (op[1] & 0x00)
3971
48.2k
        {
3972
48.2k
          case 0x00:
3973
130k
            op_semantics_22:
3974
130k
              {
3975
                /** 0100 01ss rsrc rdst   cmp %2%S2, %1 */
3976
130k
#line 552 "rx-decode.opc"
3977
130k
                int ss AU = op[0] & 0x03;
3978
130k
#line 552 "rx-decode.opc"
3979
130k
                int rsrc AU = (op[1] >> 4) & 0x0f;
3980
130k
#line 552 "rx-decode.opc"
3981
130k
                int rdst AU = op[1] & 0x0f;
3982
130k
                if (trace)
3983
0
                  {
3984
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
3985
0
                           "/** 0100 01ss rsrc rdst   cmp %2%S2, %1 */",
3986
0
                           op[0], op[1]);
3987
0
                    printf ("  ss = 0x%x,", ss);
3988
0
                    printf ("  rsrc = 0x%x,", rsrc);
3989
0
                    printf ("  rdst = 0x%x\n", rdst);
3990
0
                  }
3991
130k
                SYNTAX("cmp %2%S2, %1");
3992
130k
#line 552 "rx-decode.opc"
3993
130k
                ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3994
3995
130k
              }
3996
130k
            break;
3997
48.2k
        }
3998
130k
      break;
3999
130k
    case 0x45:
4000
31.0k
        GETBYTE ();
4001
31.0k
        switch (op[1] & 0x00)
4002
31.0k
        {
4003
31.0k
          case 0x00:
4004
31.0k
            goto op_semantics_22;
4005
0
            break;
4006
31.0k
        }
4007
0
      break;
4008
20.8k
    case 0x46:
4009
20.8k
        GETBYTE ();
4010
20.8k
        switch (op[1] & 0x00)
4011
20.8k
        {
4012
20.8k
          case 0x00:
4013
20.8k
            goto op_semantics_22;
4014
0
            break;
4015
20.8k
        }
4016
0
      break;
4017
29.9k
    case 0x47:
4018
29.9k
        GETBYTE ();
4019
29.9k
        switch (op[1] & 0x00)
4020
29.9k
        {
4021
29.9k
          case 0x00:
4022
29.9k
            goto op_semantics_22;
4023
0
            break;
4024
29.9k
        }
4025
0
      break;
4026
70.3k
    case 0x48:
4027
70.3k
        GETBYTE ();
4028
70.3k
        switch (op[1] & 0x00)
4029
70.3k
        {
4030
70.3k
          case 0x00:
4031
150k
            op_semantics_23:
4032
150k
              {
4033
                /** 0100 10ss rsrc rdst     add %1%S1, %0 */
4034
150k
#line 528 "rx-decode.opc"
4035
150k
                int ss AU = op[0] & 0x03;
4036
150k
#line 528 "rx-decode.opc"
4037
150k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4038
150k
#line 528 "rx-decode.opc"
4039
150k
                int rdst AU = op[1] & 0x0f;
4040
150k
                if (trace)
4041
0
                  {
4042
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4043
0
                           "/** 0100 10ss rsrc rdst     add %1%S1, %0 */",
4044
0
                           op[0], op[1]);
4045
0
                    printf ("  ss = 0x%x,", ss);
4046
0
                    printf ("  rsrc = 0x%x,", rsrc);
4047
0
                    printf ("  rdst = 0x%x\n", rdst);
4048
0
                  }
4049
150k
                SYNTAX("add %1%S1, %0");
4050
150k
#line 528 "rx-decode.opc"
4051
150k
                ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4052
4053
150k
              }
4054
150k
            break;
4055
70.3k
        }
4056
150k
      break;
4057
150k
    case 0x49:
4058
37.3k
        GETBYTE ();
4059
37.3k
        switch (op[1] & 0x00)
4060
37.3k
        {
4061
37.3k
          case 0x00:
4062
37.3k
            goto op_semantics_23;
4063
0
            break;
4064
37.3k
        }
4065
0
      break;
4066
18.7k
    case 0x4a:
4067
18.7k
        GETBYTE ();
4068
18.7k
        switch (op[1] & 0x00)
4069
18.7k
        {
4070
18.7k
          case 0x00:
4071
18.7k
            goto op_semantics_23;
4072
0
            break;
4073
18.7k
        }
4074
0
      break;
4075
24.2k
    case 0x4b:
4076
24.2k
        GETBYTE ();
4077
24.2k
        switch (op[1] & 0x00)
4078
24.2k
        {
4079
24.2k
          case 0x00:
4080
24.2k
            goto op_semantics_23;
4081
0
            break;
4082
24.2k
        }
4083
0
      break;
4084
53.9k
    case 0x4c:
4085
53.9k
        GETBYTE ();
4086
53.9k
        switch (op[1] & 0x00)
4087
53.9k
        {
4088
53.9k
          case 0x00:
4089
142k
            op_semantics_24:
4090
142k
              {
4091
                /** 0100 11ss rsrc rdst     mul %1%S1, %0 */
4092
142k
#line 671 "rx-decode.opc"
4093
142k
                int ss AU = op[0] & 0x03;
4094
142k
#line 671 "rx-decode.opc"
4095
142k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4096
142k
#line 671 "rx-decode.opc"
4097
142k
                int rdst AU = op[1] & 0x0f;
4098
142k
                if (trace)
4099
0
                  {
4100
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4101
0
                           "/** 0100 11ss rsrc rdst     mul %1%S1, %0 */",
4102
0
                           op[0], op[1]);
4103
0
                    printf ("  ss = 0x%x,", ss);
4104
0
                    printf ("  rsrc = 0x%x,", rsrc);
4105
0
                    printf ("  rdst = 0x%x\n", rdst);
4106
0
                  }
4107
142k
                SYNTAX("mul %1%S1, %0");
4108
142k
#line 671 "rx-decode.opc"
4109
142k
                ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4110
4111
142k
              }
4112
142k
            break;
4113
53.9k
        }
4114
142k
      break;
4115
142k
    case 0x4d:
4116
38.9k
        GETBYTE ();
4117
38.9k
        switch (op[1] & 0x00)
4118
38.9k
        {
4119
38.9k
          case 0x00:
4120
38.9k
            goto op_semantics_24;
4121
0
            break;
4122
38.9k
        }
4123
0
      break;
4124
24.6k
    case 0x4e:
4125
24.6k
        GETBYTE ();
4126
24.6k
        switch (op[1] & 0x00)
4127
24.6k
        {
4128
24.6k
          case 0x00:
4129
24.6k
            goto op_semantics_24;
4130
0
            break;
4131
24.6k
        }
4132
0
      break;
4133
25.2k
    case 0x4f:
4134
25.2k
        GETBYTE ();
4135
25.2k
        switch (op[1] & 0x00)
4136
25.2k
        {
4137
25.2k
          case 0x00:
4138
25.2k
            goto op_semantics_24;
4139
0
            break;
4140
25.2k
        }
4141
0
      break;
4142
54.3k
    case 0x50:
4143
54.3k
        GETBYTE ();
4144
54.3k
        switch (op[1] & 0x00)
4145
54.3k
        {
4146
54.3k
          case 0x00:
4147
130k
            op_semantics_25:
4148
130k
              {
4149
                /** 0101 00ss rsrc rdst     and %1%S1, %0 */
4150
130k
#line 441 "rx-decode.opc"
4151
130k
                int ss AU = op[0] & 0x03;
4152
130k
#line 441 "rx-decode.opc"
4153
130k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4154
130k
#line 441 "rx-decode.opc"
4155
130k
                int rdst AU = op[1] & 0x0f;
4156
130k
                if (trace)
4157
0
                  {
4158
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4159
0
                           "/** 0101 00ss rsrc rdst     and %1%S1, %0 */",
4160
0
                           op[0], op[1]);
4161
0
                    printf ("  ss = 0x%x,", ss);
4162
0
                    printf ("  rsrc = 0x%x,", rsrc);
4163
0
                    printf ("  rdst = 0x%x\n", rdst);
4164
0
                  }
4165
130k
                SYNTAX("and %1%S1, %0");
4166
130k
#line 441 "rx-decode.opc"
4167
130k
                ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4168
4169
130k
              }
4170
130k
            break;
4171
54.3k
        }
4172
130k
      break;
4173
130k
    case 0x51:
4174
21.3k
        GETBYTE ();
4175
21.3k
        switch (op[1] & 0x00)
4176
21.3k
        {
4177
21.2k
          case 0x00:
4178
21.2k
            goto op_semantics_25;
4179
0
            break;
4180
21.3k
        }
4181
0
      break;
4182
14.6k
    case 0x52:
4183
14.6k
        GETBYTE ();
4184
14.6k
        switch (op[1] & 0x00)
4185
14.6k
        {
4186
14.6k
          case 0x00:
4187
14.6k
            goto op_semantics_25;
4188
0
            break;
4189
14.6k
        }
4190
0
      break;
4191
39.9k
    case 0x53:
4192
39.9k
        GETBYTE ();
4193
39.9k
        switch (op[1] & 0x00)
4194
39.9k
        {
4195
39.9k
          case 0x00:
4196
39.9k
            goto op_semantics_25;
4197
0
            break;
4198
39.9k
        }
4199
0
      break;
4200
39.3k
    case 0x54:
4201
39.3k
        GETBYTE ();
4202
39.3k
        switch (op[1] & 0x00)
4203
39.3k
        {
4204
39.3k
          case 0x00:
4205
99.5k
            op_semantics_26:
4206
99.5k
              {
4207
                /** 0101 01ss rsrc rdst     or  %1%S1, %0 */
4208
99.5k
#line 459 "rx-decode.opc"
4209
99.5k
                int ss AU = op[0] & 0x03;
4210
99.5k
#line 459 "rx-decode.opc"
4211
99.5k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4212
99.5k
#line 459 "rx-decode.opc"
4213
99.5k
                int rdst AU = op[1] & 0x0f;
4214
99.5k
                if (trace)
4215
0
                  {
4216
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4217
0
                           "/** 0101 01ss rsrc rdst     or  %1%S1, %0 */",
4218
0
                           op[0], op[1]);
4219
0
                    printf ("  ss = 0x%x,", ss);
4220
0
                    printf ("  rsrc = 0x%x,", rsrc);
4221
0
                    printf ("  rdst = 0x%x\n", rdst);
4222
0
                  }
4223
99.5k
                SYNTAX("or  %1%S1, %0");
4224
99.5k
#line 459 "rx-decode.opc"
4225
99.5k
                ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4226
4227
99.5k
              }
4228
99.5k
            break;
4229
39.3k
        }
4230
99.5k
      break;
4231
99.5k
    case 0x55:
4232
24.1k
        GETBYTE ();
4233
24.1k
        switch (op[1] & 0x00)
4234
24.1k
        {
4235
24.1k
          case 0x00:
4236
24.1k
            goto op_semantics_26;
4237
0
            break;
4238
24.1k
        }
4239
0
      break;
4240
18.2k
    case 0x56:
4241
18.2k
        GETBYTE ();
4242
18.2k
        switch (op[1] & 0x00)
4243
18.2k
        {
4244
18.2k
          case 0x00:
4245
18.2k
            goto op_semantics_26;
4246
0
            break;
4247
18.2k
        }
4248
0
      break;
4249
17.8k
    case 0x57:
4250
17.8k
        GETBYTE ();
4251
17.8k
        switch (op[1] & 0x00)
4252
17.8k
        {
4253
17.8k
          case 0x00:
4254
17.8k
            goto op_semantics_26;
4255
0
            break;
4256
17.8k
        }
4257
0
      break;
4258
24.6k
    case 0x58:
4259
24.6k
        GETBYTE ();
4260
24.6k
        switch (op[1] & 0x00)
4261
24.6k
        {
4262
24.6k
          case 0x00:
4263
202k
            op_semantics_27:
4264
202k
              {
4265
                /** 0101 1 s ss rsrc rdst movu%s  %1, %0 */
4266
202k
#line 380 "rx-decode.opc"
4267
202k
                int s AU = (op[0] >> 2) & 0x01;
4268
202k
#line 380 "rx-decode.opc"
4269
202k
                int ss AU = op[0] & 0x03;
4270
202k
#line 380 "rx-decode.opc"
4271
202k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4272
202k
#line 380 "rx-decode.opc"
4273
202k
                int rdst AU = op[1] & 0x0f;
4274
202k
                if (trace)
4275
0
                  {
4276
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4277
0
                           "/** 0101 1 s ss rsrc rdst movu%s  %1, %0 */",
4278
0
                           op[0], op[1]);
4279
0
                    printf ("  s = 0x%x,", s);
4280
0
                    printf ("  ss = 0x%x,", ss);
4281
0
                    printf ("  rsrc = 0x%x,", rsrc);
4282
0
                    printf ("  rdst = 0x%x\n", rdst);
4283
0
                  }
4284
202k
                SYNTAX("movu%s  %1, %0");
4285
202k
#line 380 "rx-decode.opc"
4286
202k
                ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4287
4288
202k
              }
4289
202k
            break;
4290
24.6k
        }
4291
201k
      break;
4292
201k
    case 0x59:
4293
17.8k
        GETBYTE ();
4294
17.8k
        switch (op[1] & 0x00)
4295
17.8k
        {
4296
17.8k
          case 0x00:
4297
17.8k
            goto op_semantics_27;
4298
0
            break;
4299
17.8k
        }
4300
0
      break;
4301
17.0k
    case 0x5a:
4302
17.0k
        GETBYTE ();
4303
17.0k
        switch (op[1] & 0x00)
4304
17.0k
        {
4305
17.0k
          case 0x00:
4306
17.0k
            goto op_semantics_27;
4307
0
            break;
4308
17.0k
        }
4309
0
      break;
4310
25.8k
    case 0x5b:
4311
25.8k
        GETBYTE ();
4312
25.8k
        switch (op[1] & 0x00)
4313
25.8k
        {
4314
25.7k
          case 0x00:
4315
25.7k
            goto op_semantics_27;
4316
0
            break;
4317
25.8k
        }
4318
0
      break;
4319
28.0k
    case 0x5c:
4320
28.0k
        GETBYTE ();
4321
28.0k
        switch (op[1] & 0x00)
4322
28.0k
        {
4323
28.0k
          case 0x00:
4324
28.0k
            goto op_semantics_27;
4325
0
            break;
4326
28.0k
        }
4327
0
      break;
4328
26.1k
    case 0x5d:
4329
26.1k
        GETBYTE ();
4330
26.1k
        switch (op[1] & 0x00)
4331
26.1k
        {
4332
26.1k
          case 0x00:
4333
26.1k
            goto op_semantics_27;
4334
0
            break;
4335
26.1k
        }
4336
0
      break;
4337
22.1k
    case 0x5e:
4338
22.1k
        GETBYTE ();
4339
22.1k
        switch (op[1] & 0x00)
4340
22.1k
        {
4341
22.1k
          case 0x00:
4342
22.1k
            goto op_semantics_27;
4343
0
            break;
4344
22.1k
        }
4345
0
      break;
4346
40.2k
    case 0x5f:
4347
40.2k
        GETBYTE ();
4348
40.2k
        switch (op[1] & 0x00)
4349
40.2k
        {
4350
40.2k
          case 0x00:
4351
40.2k
            goto op_semantics_27;
4352
0
            break;
4353
40.2k
        }
4354
0
      break;
4355
49.5k
    case 0x60:
4356
49.5k
        GETBYTE ();
4357
49.5k
        switch (op[1] & 0x00)
4358
49.5k
        {
4359
49.5k
          case 0x00:
4360
49.5k
              {
4361
                /** 0110 0000 immm rdst     sub #%2, %0 */
4362
49.5k
#line 561 "rx-decode.opc"
4363
49.5k
                int immm AU = (op[1] >> 4) & 0x0f;
4364
49.5k
#line 561 "rx-decode.opc"
4365
49.5k
                int rdst AU = op[1] & 0x0f;
4366
49.5k
                if (trace)
4367
0
                  {
4368
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4369
0
                           "/** 0110 0000 immm rdst     sub #%2, %0 */",
4370
0
                           op[0], op[1]);
4371
0
                    printf ("  immm = 0x%x,", immm);
4372
0
                    printf ("  rdst = 0x%x\n", rdst);
4373
0
                  }
4374
49.5k
                SYNTAX("sub #%2, %0");
4375
49.5k
#line 561 "rx-decode.opc"
4376
49.5k
                ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4377
4378
49.5k
              }
4379
49.5k
            break;
4380
49.5k
        }
4381
49.5k
      break;
4382
64.3k
    case 0x61:
4383
64.3k
        GETBYTE ();
4384
64.3k
        switch (op[1] & 0x00)
4385
64.3k
        {
4386
64.3k
          case 0x00:
4387
64.3k
              {
4388
                /** 0110 0001 immm rdst     cmp #%2, %1 */
4389
64.3k
#line 543 "rx-decode.opc"
4390
64.3k
                int immm AU = (op[1] >> 4) & 0x0f;
4391
64.3k
#line 543 "rx-decode.opc"
4392
64.3k
                int rdst AU = op[1] & 0x0f;
4393
64.3k
                if (trace)
4394
0
                  {
4395
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4396
0
                           "/** 0110 0001 immm rdst     cmp #%2, %1 */",
4397
0
                           op[0], op[1]);
4398
0
                    printf ("  immm = 0x%x,", immm);
4399
0
                    printf ("  rdst = 0x%x\n", rdst);
4400
0
                  }
4401
64.3k
                SYNTAX("cmp #%2, %1");
4402
64.3k
#line 543 "rx-decode.opc"
4403
64.3k
                ID(sub); S2C(immm); SR(rdst); F_OSZC;
4404
4405
64.3k
              }
4406
64.3k
            break;
4407
64.3k
        }
4408
64.3k
      break;
4409
64.3k
    case 0x62:
4410
37.8k
        GETBYTE ();
4411
37.8k
        switch (op[1] & 0x00)
4412
37.8k
        {
4413
37.8k
          case 0x00:
4414
37.8k
              {
4415
                /** 0110 0010 immm rdst     add #%1, %0 */
4416
37.8k
#line 525 "rx-decode.opc"
4417
37.8k
                int immm AU = (op[1] >> 4) & 0x0f;
4418
37.8k
#line 525 "rx-decode.opc"
4419
37.8k
                int rdst AU = op[1] & 0x0f;
4420
37.8k
                if (trace)
4421
0
                  {
4422
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4423
0
                           "/** 0110 0010 immm rdst     add #%1, %0 */",
4424
0
                           op[0], op[1]);
4425
0
                    printf ("  immm = 0x%x,", immm);
4426
0
                    printf ("  rdst = 0x%x\n", rdst);
4427
0
                  }
4428
37.8k
                SYNTAX("add #%1, %0");
4429
37.8k
#line 525 "rx-decode.opc"
4430
37.8k
                ID(add); SC(immm); DR(rdst); F_OSZC;
4431
4432
37.8k
              }
4433
37.8k
            break;
4434
37.8k
        }
4435
37.8k
      break;
4436
42.6k
    case 0x63:
4437
42.6k
        GETBYTE ();
4438
42.6k
        switch (op[1] & 0x00)
4439
42.6k
        {
4440
42.6k
          case 0x00:
4441
42.6k
              {
4442
                /** 0110 0011 immm rdst     mul #%1, %0 */
4443
42.6k
#line 637 "rx-decode.opc"
4444
42.6k
                int immm AU = (op[1] >> 4) & 0x0f;
4445
42.6k
#line 637 "rx-decode.opc"
4446
42.6k
                int rdst AU = op[1] & 0x0f;
4447
42.6k
                if (trace)
4448
0
                  {
4449
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4450
0
                           "/** 0110 0011 immm rdst     mul #%1, %0 */",
4451
0
                           op[0], op[1]);
4452
0
                    printf ("  immm = 0x%x,", immm);
4453
0
                    printf ("  rdst = 0x%x\n", rdst);
4454
0
                  }
4455
42.6k
                SYNTAX("mul #%1, %0");
4456
42.6k
#line 637 "rx-decode.opc"
4457
42.6k
                if (immm == 1 && rdst == 0)
4458
239
                  {
4459
239
                    ID(nop2);
4460
239
                    SYNTAX ("nop\t; mul\t#1, r0");
4461
239
                  }
4462
42.4k
                else
4463
42.4k
                  {
4464
42.4k
                    ID(mul);
4465
42.4k
                  }
4466
42.6k
                DR(rdst); SC(immm); F_____;
4467
4468
42.6k
              }
4469
42.6k
            break;
4470
42.6k
        }
4471
42.6k
      break;
4472
51.3k
    case 0x64:
4473
51.3k
        GETBYTE ();
4474
51.3k
        switch (op[1] & 0x00)
4475
51.3k
        {
4476
51.3k
          case 0x00:
4477
51.3k
              {
4478
                /** 0110 0100 immm rdst     and #%1, %0 */
4479
51.3k
#line 435 "rx-decode.opc"
4480
51.3k
                int immm AU = (op[1] >> 4) & 0x0f;
4481
51.3k
#line 435 "rx-decode.opc"
4482
51.3k
                int rdst AU = op[1] & 0x0f;
4483
51.3k
                if (trace)
4484
0
                  {
4485
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4486
0
                           "/** 0110 0100 immm rdst     and #%1, %0 */",
4487
0
                           op[0], op[1]);
4488
0
                    printf ("  immm = 0x%x,", immm);
4489
0
                    printf ("  rdst = 0x%x\n", rdst);
4490
0
                  }
4491
51.3k
                SYNTAX("and #%1, %0");
4492
51.3k
#line 435 "rx-decode.opc"
4493
51.3k
                ID(and); SC(immm); DR(rdst); F__SZ_;
4494
4495
51.3k
              }
4496
51.3k
            break;
4497
51.3k
        }
4498
51.3k
      break;
4499
59.3k
    case 0x65:
4500
59.3k
        GETBYTE ();
4501
59.3k
        switch (op[1] & 0x00)
4502
59.3k
        {
4503
59.3k
          case 0x00:
4504
59.3k
              {
4505
                /** 0110 0101 immm rdst     or  #%1, %0 */
4506
59.3k
#line 453 "rx-decode.opc"
4507
59.3k
                int immm AU = (op[1] >> 4) & 0x0f;
4508
59.3k
#line 453 "rx-decode.opc"
4509
59.3k
                int rdst AU = op[1] & 0x0f;
4510
59.3k
                if (trace)
4511
0
                  {
4512
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4513
0
                           "/** 0110 0101 immm rdst     or  #%1, %0 */",
4514
0
                           op[0], op[1]);
4515
0
                    printf ("  immm = 0x%x,", immm);
4516
0
                    printf ("  rdst = 0x%x\n", rdst);
4517
0
                  }
4518
59.3k
                SYNTAX("or  #%1, %0");
4519
59.3k
#line 453 "rx-decode.opc"
4520
59.3k
                ID(or); SC(immm); DR(rdst); F__SZ_;
4521
4522
59.3k
              }
4523
59.3k
            break;
4524
59.3k
        }
4525
59.3k
      break;
4526
59.3k
    case 0x66:
4527
37.6k
        GETBYTE ();
4528
37.6k
        switch (op[1] & 0x00)
4529
37.6k
        {
4530
37.6k
          case 0x00:
4531
37.6k
              {
4532
                /** 0110 0110 immm rdst   mov%s #%1, %0 */
4533
37.6k
#line 329 "rx-decode.opc"
4534
37.6k
                int immm AU = (op[1] >> 4) & 0x0f;
4535
37.6k
#line 329 "rx-decode.opc"
4536
37.6k
                int rdst AU = op[1] & 0x0f;
4537
37.6k
                if (trace)
4538
0
                  {
4539
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4540
0
                           "/** 0110 0110 immm rdst   mov%s #%1, %0 */",
4541
0
                           op[0], op[1]);
4542
0
                    printf ("  immm = 0x%x,", immm);
4543
0
                    printf ("  rdst = 0x%x\n", rdst);
4544
0
                  }
4545
37.6k
                SYNTAX("mov%s #%1, %0");
4546
37.6k
#line 329 "rx-decode.opc"
4547
37.6k
                ID(mov); DR(rdst); SC(immm); F_____;
4548
4549
37.6k
              }
4550
37.6k
            break;
4551
37.6k
        }
4552
37.6k
      break;
4553
44.8k
    case 0x67:
4554
44.8k
        {
4555
          /** 0110 0111     rtsd  #%1 */
4556
44.8k
          if (trace)
4557
0
            {
4558
0
              printf ("\033[33m%s\033[0m  %02x\n",
4559
0
                     "/** 0110 0111     rtsd  #%1 */",
4560
0
                     op[0]);
4561
0
            }
4562
44.8k
          SYNTAX("rtsd  #%1");
4563
44.8k
#line 426 "rx-decode.opc"
4564
44.8k
          ID(rtsd); SC(IMM(1) * 4);
4565
4566
44.8k
        }
4567
44.8k
      break;
4568
55.2k
    case 0x68:
4569
55.2k
        GETBYTE ();
4570
55.2k
        switch (op[1] & 0x00)
4571
55.2k
        {
4572
55.2k
          case 0x00:
4573
98.8k
            op_semantics_28:
4574
98.8k
              {
4575
                /** 0110 100i mmmm rdst     shlr  #%2, %0 */
4576
98.8k
#line 751 "rx-decode.opc"
4577
98.8k
                int i AU = op[0] & 0x01;
4578
98.8k
#line 751 "rx-decode.opc"
4579
98.8k
                int mmmm AU = (op[1] >> 4) & 0x0f;
4580
98.8k
#line 751 "rx-decode.opc"
4581
98.8k
                int rdst AU = op[1] & 0x0f;
4582
98.8k
                if (trace)
4583
0
                  {
4584
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4585
0
                           "/** 0110 100i mmmm rdst     shlr  #%2, %0 */",
4586
0
                           op[0], op[1]);
4587
0
                    printf ("  i = 0x%x,", i);
4588
0
                    printf ("  mmmm = 0x%x,", mmmm);
4589
0
                    printf ("  rdst = 0x%x\n", rdst);
4590
0
                  }
4591
98.8k
                SYNTAX("shlr  #%2, %0");
4592
98.8k
#line 751 "rx-decode.opc"
4593
98.8k
                ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4594
4595
98.8k
              }
4596
98.8k
            break;
4597
55.2k
        }
4598
98.8k
      break;
4599
98.8k
    case 0x69:
4600
43.5k
        GETBYTE ();
4601
43.5k
        switch (op[1] & 0x00)
4602
43.5k
        {
4603
43.5k
          case 0x00:
4604
43.5k
            goto op_semantics_28;
4605
0
            break;
4606
43.5k
        }
4607
0
      break;
4608
18.8k
    case 0x6a:
4609
18.8k
        GETBYTE ();
4610
18.8k
        switch (op[1] & 0x00)
4611
18.8k
        {
4612
18.8k
          case 0x00:
4613
45.6k
            op_semantics_29:
4614
45.6k
              {
4615
                /** 0110 101i mmmm rdst     shar  #%2, %0 */
4616
45.6k
#line 741 "rx-decode.opc"
4617
45.6k
                int i AU = op[0] & 0x01;
4618
45.6k
#line 741 "rx-decode.opc"
4619
45.6k
                int mmmm AU = (op[1] >> 4) & 0x0f;
4620
45.6k
#line 741 "rx-decode.opc"
4621
45.6k
                int rdst AU = op[1] & 0x0f;
4622
45.6k
                if (trace)
4623
0
                  {
4624
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4625
0
                           "/** 0110 101i mmmm rdst     shar  #%2, %0 */",
4626
0
                           op[0], op[1]);
4627
0
                    printf ("  i = 0x%x,", i);
4628
0
                    printf ("  mmmm = 0x%x,", mmmm);
4629
0
                    printf ("  rdst = 0x%x\n", rdst);
4630
0
                  }
4631
45.6k
                SYNTAX("shar  #%2, %0");
4632
45.6k
#line 741 "rx-decode.opc"
4633
45.6k
                ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4634
4635
45.6k
              }
4636
45.6k
            break;
4637
18.8k
        }
4638
45.6k
      break;
4639
45.6k
    case 0x6b:
4640
26.7k
        GETBYTE ();
4641
26.7k
        switch (op[1] & 0x00)
4642
26.7k
        {
4643
26.7k
          case 0x00:
4644
26.7k
            goto op_semantics_29;
4645
0
            break;
4646
26.7k
        }
4647
0
      break;
4648
41.7k
    case 0x6c:
4649
41.7k
        GETBYTE ();
4650
41.7k
        switch (op[1] & 0x00)
4651
41.7k
        {
4652
41.7k
          case 0x00:
4653
78.5k
            op_semantics_30:
4654
78.5k
              {
4655
                /** 0110 110i mmmm rdst     shll  #%2, %0 */
4656
78.5k
#line 731 "rx-decode.opc"
4657
78.5k
                int i AU = op[0] & 0x01;
4658
78.5k
#line 731 "rx-decode.opc"
4659
78.5k
                int mmmm AU = (op[1] >> 4) & 0x0f;
4660
78.5k
#line 731 "rx-decode.opc"
4661
78.5k
                int rdst AU = op[1] & 0x0f;
4662
78.5k
                if (trace)
4663
0
                  {
4664
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4665
0
                           "/** 0110 110i mmmm rdst     shll  #%2, %0 */",
4666
0
                           op[0], op[1]);
4667
0
                    printf ("  i = 0x%x,", i);
4668
0
                    printf ("  mmmm = 0x%x,", mmmm);
4669
0
                    printf ("  rdst = 0x%x\n", rdst);
4670
0
                  }
4671
78.5k
                SYNTAX("shll  #%2, %0");
4672
78.5k
#line 731 "rx-decode.opc"
4673
78.5k
                ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4674
4675
78.5k
              }
4676
78.5k
            break;
4677
41.7k
        }
4678
78.5k
      break;
4679
78.5k
    case 0x6d:
4680
36.8k
        GETBYTE ();
4681
36.8k
        switch (op[1] & 0x00)
4682
36.8k
        {
4683
36.8k
          case 0x00:
4684
36.8k
            goto op_semantics_30;
4685
0
            break;
4686
36.8k
        }
4687
0
      break;
4688
52.6k
    case 0x6e:
4689
52.6k
        GETBYTE ();
4690
52.6k
        switch (op[1] & 0x00)
4691
52.6k
        {
4692
52.6k
          case 0x00:
4693
52.6k
              {
4694
                /** 0110 1110 dsta dstb   pushm %1-%2 */
4695
52.6k
#line 393 "rx-decode.opc"
4696
52.6k
                int dsta AU = (op[1] >> 4) & 0x0f;
4697
52.6k
#line 393 "rx-decode.opc"
4698
52.6k
                int dstb AU = op[1] & 0x0f;
4699
52.6k
                if (trace)
4700
0
                  {
4701
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4702
0
                           "/** 0110 1110 dsta dstb   pushm %1-%2 */",
4703
0
                           op[0], op[1]);
4704
0
                    printf ("  dsta = 0x%x,", dsta);
4705
0
                    printf ("  dstb = 0x%x\n", dstb);
4706
0
                  }
4707
52.6k
                SYNTAX("pushm %1-%2");
4708
52.6k
#line 393 "rx-decode.opc"
4709
52.6k
                ID(pushm); SR(dsta); S2R(dstb); F_____;
4710
4711
52.6k
              }
4712
52.6k
            break;
4713
52.6k
        }
4714
52.6k
      break;
4715
52.6k
    case 0x6f:
4716
48.9k
        GETBYTE ();
4717
48.9k
        switch (op[1] & 0x00)
4718
48.9k
        {
4719
48.9k
          case 0x00:
4720
48.9k
              {
4721
                /** 0110 1111 dsta dstb   popm  %1-%2 */
4722
48.9k
#line 390 "rx-decode.opc"
4723
48.9k
                int dsta AU = (op[1] >> 4) & 0x0f;
4724
48.9k
#line 390 "rx-decode.opc"
4725
48.9k
                int dstb AU = op[1] & 0x0f;
4726
48.9k
                if (trace)
4727
0
                  {
4728
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4729
0
                           "/** 0110 1111 dsta dstb   popm  %1-%2 */",
4730
0
                           op[0], op[1]);
4731
0
                    printf ("  dsta = 0x%x,", dsta);
4732
0
                    printf ("  dstb = 0x%x\n", dstb);
4733
0
                  }
4734
48.9k
                SYNTAX("popm  %1-%2");
4735
48.9k
#line 390 "rx-decode.opc"
4736
48.9k
                ID(popm); SR(dsta); S2R(dstb); F_____;
4737
4738
48.9k
              }
4739
48.9k
            break;
4740
48.9k
        }
4741
48.9k
      break;
4742
48.9k
    case 0x70:
4743
42.4k
        GETBYTE ();
4744
42.4k
        switch (op[1] & 0x00)
4745
42.4k
        {
4746
42.4k
          case 0x00:
4747
194k
            op_semantics_31:
4748
194k
              {
4749
                /** 0111 00im rsrc rdst     add #%1, %2, %0 */
4750
194k
#line 534 "rx-decode.opc"
4751
194k
                int im AU = op[0] & 0x03;
4752
194k
#line 534 "rx-decode.opc"
4753
194k
                int rsrc AU = (op[1] >> 4) & 0x0f;
4754
194k
#line 534 "rx-decode.opc"
4755
194k
                int rdst AU = op[1] & 0x0f;
4756
194k
                if (trace)
4757
0
                  {
4758
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4759
0
                           "/** 0111 00im rsrc rdst     add #%1, %2, %0 */",
4760
0
                           op[0], op[1]);
4761
0
                    printf ("  im = 0x%x,", im);
4762
0
                    printf ("  rsrc = 0x%x,", rsrc);
4763
0
                    printf ("  rdst = 0x%x\n", rdst);
4764
0
                  }
4765
194k
                SYNTAX("add #%1, %2, %0");
4766
194k
#line 534 "rx-decode.opc"
4767
194k
                ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4768
4769
194k
              }
4770
194k
            break;
4771
42.4k
        }
4772
194k
      break;
4773
194k
    case 0x71:
4774
37.2k
        GETBYTE ();
4775
37.2k
        switch (op[1] & 0x00)
4776
37.2k
        {
4777
37.1k
          case 0x00:
4778
37.1k
            goto op_semantics_31;
4779
0
            break;
4780
37.2k
        }
4781
0
      break;
4782
52.5k
    case 0x72:
4783
52.5k
        GETBYTE ();
4784
52.5k
        switch (op[1] & 0x00)
4785
52.5k
        {
4786
52.5k
          case 0x00:
4787
52.5k
            goto op_semantics_31;
4788
0
            break;
4789
52.5k
        }
4790
0
      break;
4791
62.3k
    case 0x73:
4792
62.3k
        GETBYTE ();
4793
62.3k
        switch (op[1] & 0x00)
4794
62.3k
        {
4795
62.3k
          case 0x00:
4796
62.3k
            goto op_semantics_31;
4797
0
            break;
4798
62.3k
        }
4799
0
      break;
4800
59.3k
    case 0x74:
4801
59.3k
        GETBYTE ();
4802
59.3k
        switch (op[1] & 0xf0)
4803
59.3k
        {
4804
15.1k
          case 0x00:
4805
41.3k
            op_semantics_32:
4806
41.3k
              {
4807
                /** 0111 01im 0000 rsrc   cmp #%2, %1%S1 */
4808
41.3k
#line 546 "rx-decode.opc"
4809
41.3k
                int im AU = op[0] & 0x03;
4810
41.3k
#line 546 "rx-decode.opc"
4811
41.3k
                int rsrc AU = op[1] & 0x0f;
4812
41.3k
                if (trace)
4813
0
                  {
4814
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4815
0
                           "/** 0111 01im 0000 rsrc   cmp #%2, %1%S1 */",
4816
0
                           op[0], op[1]);
4817
0
                    printf ("  im = 0x%x,", im);
4818
0
                    printf ("  rsrc = 0x%x\n", rsrc);
4819
0
                  }
4820
41.3k
                SYNTAX("cmp #%2, %1%S1");
4821
41.3k
#line 546 "rx-decode.opc"
4822
41.3k
                ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4823
4824
41.3k
              }
4825
41.3k
            break;
4826
1.84k
          case 0x10:
4827
6.66k
            op_semantics_33:
4828
6.66k
              {
4829
                /** 0111 01im 0001rdst      mul #%1, %0 */
4830
6.66k
#line 649 "rx-decode.opc"
4831
6.66k
                int im AU = op[0] & 0x03;
4832
6.66k
#line 649 "rx-decode.opc"
4833
6.66k
                int rdst AU = op[1] & 0x0f;
4834
6.66k
                if (trace)
4835
0
                  {
4836
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4837
0
                           "/** 0111 01im 0001rdst      mul #%1, %0 */",
4838
0
                           op[0], op[1]);
4839
0
                    printf ("  im = 0x%x,", im);
4840
0
                    printf ("  rdst = 0x%x\n", rdst);
4841
0
                  }
4842
6.66k
                SYNTAX("mul #%1, %0");
4843
6.66k
#line 649 "rx-decode.opc"
4844
6.66k
                int val = IMMex(im);
4845
6.66k
                if (val == 1 && rdst == 0)
4846
103
                  {
4847
103
                    SYNTAX("nop\t; mul\t#1, r0");
4848
103
                    switch (im)
4849
103
                {
4850
1
                case 2: ID(nop4); break;
4851
0
                case 3: ID(nop5); break;
4852
42
                case 0: ID(nop6); break;
4853
60
                default:
4854
60
                  ID(mul);
4855
60
                  SYNTAX("mul #%1, %0");
4856
60
                  break;
4857
103
                }
4858
103
                  }
4859
6.56k
                else
4860
6.56k
                  {
4861
6.56k
                    ID(mul);
4862
6.56k
                  }
4863
6.66k
                DR(rdst); SC(val); F_____;
4864
4865
6.66k
              }
4866
0
            break;
4867
4.79k
          case 0x20:
4868
12.8k
            op_semantics_34:
4869
12.8k
              {
4870
                /** 0111 01im 0010 rdst     and #%1, %0 */
4871
12.8k
#line 438 "rx-decode.opc"
4872
12.8k
                int im AU = op[0] & 0x03;
4873
12.8k
#line 438 "rx-decode.opc"
4874
12.8k
                int rdst AU = op[1] & 0x0f;
4875
12.8k
                if (trace)
4876
0
                  {
4877
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4878
0
                           "/** 0111 01im 0010 rdst     and #%1, %0 */",
4879
0
                           op[0], op[1]);
4880
0
                    printf ("  im = 0x%x,", im);
4881
0
                    printf ("  rdst = 0x%x\n", rdst);
4882
0
                  }
4883
12.8k
                SYNTAX("and #%1, %0");
4884
12.8k
#line 438 "rx-decode.opc"
4885
12.8k
                ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4886
4887
12.8k
              }
4888
12.8k
            break;
4889
2.03k
          case 0x30:
4890
8.97k
            op_semantics_35:
4891
8.97k
              {
4892
                /** 0111 01im 0011 rdst     or  #%1, %0 */
4893
8.97k
#line 456 "rx-decode.opc"
4894
8.97k
                int im AU = op[0] & 0x03;
4895
8.97k
#line 456 "rx-decode.opc"
4896
8.97k
                int rdst AU = op[1] & 0x0f;
4897
8.97k
                if (trace)
4898
0
                  {
4899
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
4900
0
                           "/** 0111 01im 0011 rdst     or  #%1, %0 */",
4901
0
                           op[0], op[1]);
4902
0
                    printf ("  im = 0x%x,", im);
4903
0
                    printf ("  rdst = 0x%x\n", rdst);
4904
0
                  }
4905
8.97k
                SYNTAX("or  #%1, %0");
4906
8.97k
#line 456 "rx-decode.opc"
4907
8.97k
                ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4908
4909
8.97k
              }
4910
8.97k
            break;
4911
35.4k
          default: UNSUPPORTED(); break;
4912
59.3k
        }
4913
105k
      break;
4914
105k
    case 0x75:
4915
53.1k
        GETBYTE ();
4916
53.1k
        switch (op[1] & 0xff)
4917
53.1k
        {
4918
6.93k
          case 0x00:
4919
7.16k
          case 0x01:
4920
7.22k
          case 0x02:
4921
7.29k
          case 0x03:
4922
7.56k
          case 0x04:
4923
7.95k
          case 0x05:
4924
8.05k
          case 0x06:
4925
8.58k
          case 0x07:
4926
8.66k
          case 0x08:
4927
10.1k
          case 0x09:
4928
10.1k
          case 0x0a:
4929
11.6k
          case 0x0b:
4930
11.7k
          case 0x0c:
4931
12.4k
          case 0x0d:
4932
12.9k
          case 0x0e:
4933
13.0k
          case 0x0f:
4934
13.0k
            goto op_semantics_32;
4935
0
            break;
4936
156
          case 0x10:
4937
427
          case 0x11:
4938
726
          case 0x12:
4939
883
          case 0x13:
4940
967
          case 0x14:
4941
1.05k
          case 0x15:
4942
1.19k
          case 0x16:
4943
1.25k
          case 0x17:
4944
1.35k
          case 0x18:
4945
1.38k
          case 0x19:
4946
1.43k
          case 0x1a:
4947
1.53k
          case 0x1b:
4948
1.64k
          case 0x1c:
4949
1.72k
          case 0x1d:
4950
1.85k
          case 0x1e:
4951
2.01k
          case 0x1f:
4952
2.01k
            goto op_semantics_33;
4953
0
            break;
4954
61
          case 0x20:
4955
345
          case 0x21:
4956
497
          case 0x22:
4957
968
          case 0x23:
4958
1.04k
          case 0x24:
4959
1.19k
          case 0x25:
4960
1.34k
          case 0x26:
4961
1.38k
          case 0x27:
4962
1.45k
          case 0x28:
4963
1.63k
          case 0x29:
4964
1.71k
          case 0x2a:
4965
1.77k
          case 0x2b:
4966
2.25k
          case 0x2c:
4967
2.46k
          case 0x2d:
4968
2.62k
          case 0x2e:
4969
3.00k
          case 0x2f:
4970
3.00k
            goto op_semantics_34;
4971
0
            break;
4972
55
          case 0x30:
4973
806
          case 0x31:
4974
1.00k
          case 0x32:
4975
1.04k
          case 0x33:
4976
1.12k
          case 0x34:
4977
1.45k
          case 0x35:
4978
1.67k
          case 0x36:
4979
1.72k
          case 0x37:
4980
1.78k
          case 0x38:
4981
1.91k
          case 0x39:
4982
1.95k
          case 0x3a:
4983
1.96k
          case 0x3b:
4984
2.14k
          case 0x3c:
4985
2.20k
          case 0x3d:
4986
2.26k
          case 0x3e:
4987
2.58k
          case 0x3f:
4988
2.58k
            goto op_semantics_35;
4989
0
            break;
4990
47
          case 0x40:
4991
187
          case 0x41:
4992
203
          case 0x42:
4993
254
          case 0x43:
4994
596
          case 0x44:
4995
686
          case 0x45:
4996
713
          case 0x46:
4997
802
          case 0x47:
4998
832
          case 0x48:
4999
881
          case 0x49:
5000
1.17k
          case 0x4a:
5001
1.23k
          case 0x4b:
5002
1.34k
          case 0x4c:
5003
1.38k
          case 0x4d:
5004
1.43k
          case 0x4e:
5005
1.49k
          case 0x4f:
5006
1.49k
              {
5007
                /** 0111 0101 0100 rdst   mov%s #%1, %0 */
5008
1.49k
#line 310 "rx-decode.opc"
5009
1.49k
                int rdst AU = op[1] & 0x0f;
5010
1.49k
                if (trace)
5011
0
                  {
5012
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5013
0
                           "/** 0111 0101 0100 rdst   mov%s #%1, %0 */",
5014
0
                           op[0], op[1]);
5015
0
                    printf ("  rdst = 0x%x\n", rdst);
5016
0
                  }
5017
1.49k
                SYNTAX("mov%s #%1, %0");
5018
1.49k
#line 310 "rx-decode.opc"
5019
1.49k
                ID(mov); DR(rdst); SC(IMM (1)); F_____;
5020
5021
1.49k
              }
5022
1.49k
            break;
5023
67
          case 0x50:
5024
425
          case 0x51:
5025
466
          case 0x52:
5026
509
          case 0x53:
5027
715
          case 0x54:
5028
839
          case 0x55:
5029
896
          case 0x56:
5030
908
          case 0x57:
5031
1.07k
          case 0x58:
5032
1.16k
          case 0x59:
5033
1.45k
          case 0x5a:
5034
1.58k
          case 0x5b:
5035
1.61k
          case 0x5c:
5036
1.72k
          case 0x5d:
5037
1.76k
          case 0x5e:
5038
2.30k
          case 0x5f:
5039
2.30k
              {
5040
                /** 0111 0101 0101 rsrc     cmp #%2, %1 */
5041
2.30k
#line 549 "rx-decode.opc"
5042
2.30k
                int rsrc AU = op[1] & 0x0f;
5043
2.30k
                if (trace)
5044
0
                  {
5045
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5046
0
                           "/** 0111 0101 0101 rsrc     cmp #%2, %1 */",
5047
0
                           op[0], op[1]);
5048
0
                    printf ("  rsrc = 0x%x\n", rsrc);
5049
0
                  }
5050
2.30k
                SYNTAX("cmp #%2, %1");
5051
2.30k
#line 549 "rx-decode.opc"
5052
2.30k
                ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5053
5054
2.30k
              }
5055
2.30k
            break;
5056
104
          case 0x60:
5057
104
              {
5058
                /** 0111 0101 0110 0000   int #%1 */
5059
104
                if (trace)
5060
0
                  {
5061
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
5062
0
                           "/** 0111 0101 0110 0000   int #%1 */",
5063
0
                           op[0], op[1]);
5064
0
                  }
5065
104
                SYNTAX("int #%1");
5066
104
#line 1056 "rx-decode.opc"
5067
104
                ID(int); SC(IMM(1));
5068
5069
104
              }
5070
104
            break;
5071
79
          case 0x70:
5072
79
              GETBYTE ();
5073
79
              switch (op[2] & 0xf0)
5074
79
              {
5075
17
                case 0x00:
5076
17
                    {
5077
                      /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
5078
17
#line 1023 "rx-decode.opc"
5079
17
                      int immm AU = op[2] & 0x0f;
5080
17
                      if (trace)
5081
0
                        {
5082
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5083
0
                                 "/** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */",
5084
0
                                 op[0], op[1], op[2]);
5085
0
                          printf ("  immm = 0x%x\n", immm);
5086
0
                        }
5087
17
                      SYNTAX("mvtipl  #%1");
5088
17
#line 1023 "rx-decode.opc"
5089
17
                      ID(mvtipl); SC(immm);
5090
5091
17
                    }
5092
17
                  break;
5093
62
                default: UNSUPPORTED(); break;
5094
79
              }
5095
79
            break;
5096
334
          case 0x90:
5097
334
              GETBYTE ();
5098
334
              switch (op[2] & 0xff)
5099
334
              {
5100
1
                case 0x1b:
5101
1
                    {
5102
                      /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103
1
                      if (trace)
5104
0
                        {
5105
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5106
0
                                 "/** 0111 0101 1001 0000 0001 1011 mvfdr */",
5107
0
                                 op[0], op[1], op[2]);
5108
0
                        }
5109
1
                      SYNTAX("mvfdr");
5110
1
#line 1229 "rx-decode.opc"
5111
1
                      ID(mvfdr); F_____;
5112
5113
1
                    }
5114
1
                  break;
5115
333
                default: UNSUPPORTED(); break;
5116
334
              }
5117
334
            break;
5118
334
          case 0xa0:
5119
54
              GETBYTE ();
5120
54
              switch (op[2] & 0x00)
5121
54
              {
5122
54
                case 0x00:
5123
54
                    {
5124
                      /** 0111 0101 1010 0000 rdst rnum dpushm.l  %1-%2 */
5125
54
#line 1223 "rx-decode.opc"
5126
54
                      int rdst AU = (op[2] >> 4) & 0x0f;
5127
54
#line 1223 "rx-decode.opc"
5128
54
                      int rnum AU = op[2] & 0x0f;
5129
54
                      if (trace)
5130
0
                        {
5131
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5132
0
                                 "/** 0111 0101 1010 0000 rdst rnum dpushm.l  %1-%2 */",
5133
0
                                 op[0], op[1], op[2]);
5134
0
                          printf ("  rdst = 0x%x,", rdst);
5135
0
                          printf ("  rnum = 0x%x\n", rnum);
5136
0
                        }
5137
54
                      SYNTAX("dpushm.l  %1-%2");
5138
54
#line 1223 "rx-decode.opc"
5139
54
                      ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
5140
5141
54
                    }
5142
54
                  break;
5143
54
              }
5144
54
            break;
5145
1.00k
          case 0xa8:
5146
1.00k
              GETBYTE ();
5147
1.00k
              switch (op[2] & 0x00)
5148
1.00k
              {
5149
1.00k
                case 0x00:
5150
1.00k
                    {
5151
                      /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */
5152
1.00k
#line 1217 "rx-decode.opc"
5153
1.00k
                      int rdst AU = (op[2] >> 4) & 0x0f;
5154
1.00k
#line 1217 "rx-decode.opc"
5155
1.00k
                      int rnum AU = op[2] & 0x0f;
5156
1.00k
                      if (trace)
5157
0
                        {
5158
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5159
0
                                 "/** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */",
5160
0
                                 op[0], op[1], op[2]);
5161
0
                          printf ("  rdst = 0x%x,", rdst);
5162
0
                          printf ("  rnum = 0x%x\n", rnum);
5163
0
                        }
5164
1.00k
                      SYNTAX("dpopm.l %1-%2");
5165
1.00k
#line 1217 "rx-decode.opc"
5166
1.00k
                      ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
5167
5168
1.00k
                    }
5169
1.00k
                  break;
5170
1.00k
              }
5171
1.00k
            break;
5172
1.28k
          case 0xb0:
5173
1.28k
              GETBYTE ();
5174
1.28k
              switch (op[2] & 0x00)
5175
1.28k
              {
5176
1.28k
                case 0x00:
5177
1.28k
                    {
5178
                      /** 0111 0101 1011 0000 rdst rnum dpushm.d  %1-%2 */
5179
1.28k
#line 1220 "rx-decode.opc"
5180
1.28k
                      int rdst AU = (op[2] >> 4) & 0x0f;
5181
1.28k
#line 1220 "rx-decode.opc"
5182
1.28k
                      int rnum AU = op[2] & 0x0f;
5183
1.28k
                      if (trace)
5184
0
                        {
5185
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5186
0
                                 "/** 0111 0101 1011 0000 rdst rnum dpushm.d  %1-%2 */",
5187
0
                                 op[0], op[1], op[2]);
5188
0
                          printf ("  rdst = 0x%x,", rdst);
5189
0
                          printf ("  rnum = 0x%x\n", rnum);
5190
0
                        }
5191
1.28k
                      SYNTAX("dpushm.d  %1-%2");
5192
1.28k
#line 1220 "rx-decode.opc"
5193
1.28k
                      ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
5194
5195
1.28k
                    }
5196
1.28k
                  break;
5197
1.28k
              }
5198
1.28k
            break;
5199
1.28k
          case 0xb8:
5200
180
              GETBYTE ();
5201
180
              switch (op[2] & 0x00)
5202
180
              {
5203
180
                case 0x00:
5204
180
                    {
5205
                      /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */
5206
180
#line 1214 "rx-decode.opc"
5207
180
                      int rdst AU = (op[2] >> 4) & 0x0f;
5208
180
#line 1214 "rx-decode.opc"
5209
180
                      int rnum AU = op[2] & 0x0f;
5210
180
                      if (trace)
5211
0
                        {
5212
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5213
0
                                 "/** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */",
5214
0
                                 op[0], op[1], op[2]);
5215
0
                          printf ("  rdst = 0x%x,", rdst);
5216
0
                          printf ("  rnum = 0x%x\n", rnum);
5217
0
                        }
5218
180
                      SYNTAX("dpopm.d %1-%2");
5219
180
#line 1214 "rx-decode.opc"
5220
180
                      ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221
5222
180
                    }
5223
180
                  break;
5224
180
              }
5225
180
            break;
5226
25.6k
          default: UNSUPPORTED(); break;
5227
53.1k
        }
5228
32.4k
      break;
5229
74.5k
    case 0x76:
5230
74.5k
        GETBYTE ();
5231
74.5k
        switch (op[1] & 0xff)
5232
74.5k
        {
5233
5.94k
          case 0x00:
5234
6.34k
          case 0x01:
5235
7.10k
          case 0x02:
5236
7.16k
          case 0x03:
5237
7.21k
          case 0x04:
5238
7.34k
          case 0x05:
5239
7.56k
          case 0x06:
5240
7.73k
          case 0x07:
5241
7.79k
          case 0x08:
5242
7.94k
          case 0x09:
5243
8.02k
          case 0x0a:
5244
8.08k
          case 0x0b:
5245
8.39k
          case 0x0c:
5246
8.52k
          case 0x0d:
5247
8.56k
          case 0x0e:
5248
8.65k
          case 0x0f:
5249
8.65k
            goto op_semantics_32;
5250
0
            break;
5251
92
          case 0x10:
5252
223
          case 0x11:
5253
235
          case 0x12:
5254
269
          case 0x13:
5255
311
          case 0x14:
5256
394
          case 0x15:
5257
470
          case 0x16:
5258
499
          case 0x17:
5259
556
          case 0x18:
5260
582
          case 0x19:
5261
618
          case 0x1a:
5262
1.09k
          case 0x1b:
5263
1.18k
          case 0x1c:
5264
1.21k
          case 0x1d:
5265
1.27k
          case 0x1e:
5266
1.39k
          case 0x1f:
5267
1.39k
            goto op_semantics_33;
5268
0
            break;
5269
77
          case 0x20:
5270
96
          case 0x21:
5271
132
          case 0x22:
5272
179
          case 0x23:
5273
807
          case 0x24:
5274
902
          case 0x25:
5275
944
          case 0x26:
5276
1.07k
          case 0x27:
5277
1.10k
          case 0x28:
5278
1.37k
          case 0x29:
5279
1.40k
          case 0x2a:
5280
1.78k
          case 0x2b:
5281
1.90k
          case 0x2c:
5282
2.02k
          case 0x2d:
5283
2.47k
          case 0x2e:
5284
2.70k
          case 0x2f:
5285
2.70k
            goto op_semantics_34;
5286
0
            break;
5287
160
          case 0x30:
5288
552
          case 0x31:
5289
667
          case 0x32:
5290
1.06k
          case 0x33:
5291
1.24k
          case 0x34:
5292
1.28k
          case 0x35:
5293
1.40k
          case 0x36:
5294
1.61k
          case 0x37:
5295
1.70k
          case 0x38:
5296
1.96k
          case 0x39:
5297
2.15k
          case 0x3a:
5298
2.29k
          case 0x3b:
5299
2.34k
          case 0x3c:
5300
2.41k
          case 0x3d:
5301
2.48k
          case 0x3e:
5302
2.60k
          case 0x3f:
5303
2.60k
            goto op_semantics_35;
5304
0
            break;
5305
19.3k
          case 0x90:
5306
19.3k
              GETBYTE ();
5307
19.3k
              switch (op[2] & 0xff)
5308
19.3k
              {
5309
343
                case 0x00:
5310
343
                    GETBYTE ();
5311
343
                    switch (op[3] & 0x00)
5312
343
                    {
5313
343
                      case 0x00:
5314
1.25k
                        op_semantics_36:
5315
1.25k
                          {
5316
                            /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd  %1, %2, %0 */
5317
1.25k
#line 1238 "rx-decode.opc"
5318
1.25k
                            int srcb AU = (op[2] >> 4) & 0x0f;
5319
1.25k
#line 1238 "rx-decode.opc"
5320
1.25k
                            int rdst AU = (op[3] >> 4) & 0x0f;
5321
1.25k
#line 1238 "rx-decode.opc"
5322
1.25k
                            int srca AU = op[3] & 0x0f;
5323
1.25k
                            if (trace)
5324
0
                              {
5325
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5326
0
                                       "/** 0111 0110 1001 0000 srcb 0000 rdst srca dadd  %1, %2, %0 */",
5327
0
                                       op[0], op[1], op[2], op[3]);
5328
0
                                printf ("  srcb = 0x%x,", srcb);
5329
0
                                printf ("  rdst = 0x%x,", rdst);
5330
0
                                printf ("  srca = 0x%x\n", srca);
5331
0
                              }
5332
1.25k
                            SYNTAX("dadd  %1, %2, %0");
5333
1.25k
#line 1238 "rx-decode.opc"
5334
1.25k
                            ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335
5336
1.25k
                          }
5337
1.25k
                        break;
5338
343
                    }
5339
1.25k
                  break;
5340
1.25k
                case 0x01:
5341
143
                    GETBYTE ();
5342
143
                    switch (op[3] & 0x00)
5343
143
                    {
5344
143
                      case 0x00:
5345
2.13k
                        op_semantics_37:
5346
2.13k
                          {
5347
                            /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub  %1, %2, %0 */
5348
2.13k
#line 1259 "rx-decode.opc"
5349
2.13k
                            int srcb AU = (op[2] >> 4) & 0x0f;
5350
2.13k
#line 1259 "rx-decode.opc"
5351
2.13k
                            int rdst AU = (op[3] >> 4) & 0x0f;
5352
2.13k
#line 1259 "rx-decode.opc"
5353
2.13k
                            int srca AU = op[3] & 0x0f;
5354
2.13k
                            if (trace)
5355
0
                              {
5356
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5357
0
                                       "/** 0111 0110 1001 0000 srcb 0001 rdst srca dsub  %1, %2, %0 */",
5358
0
                                       op[0], op[1], op[2], op[3]);
5359
0
                                printf ("  srcb = 0x%x,", srcb);
5360
0
                                printf ("  rdst = 0x%x,", rdst);
5361
0
                                printf ("  srca = 0x%x\n", srca);
5362
0
                              }
5363
2.13k
                            SYNTAX("dsub  %1, %2, %0");
5364
2.13k
#line 1259 "rx-decode.opc"
5365
2.13k
                            ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366
5367
2.13k
                          }
5368
2.13k
                        break;
5369
143
                    }
5370
2.13k
                  break;
5371
2.13k
                case 0x02:
5372
3
                    GETBYTE ();
5373
3
                    switch (op[3] & 0x00)
5374
3
                    {
5375
3
                      case 0x00:
5376
2.09k
                        op_semantics_38:
5377
2.09k
                          {
5378
                            /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul  %1, %2, %0 */
5379
2.09k
#line 1247 "rx-decode.opc"
5380
2.09k
                            int srcb AU = (op[2] >> 4) & 0x0f;
5381
2.09k
#line 1247 "rx-decode.opc"
5382
2.09k
                            int rdst AU = (op[3] >> 4) & 0x0f;
5383
2.09k
#line 1247 "rx-decode.opc"
5384
2.09k
                            int srca AU = op[3] & 0x0f;
5385
2.09k
                            if (trace)
5386
0
                              {
5387
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5388
0
                                       "/** 0111 0110 1001 0000 srcb 0010 rdst srca dmul  %1, %2, %0 */",
5389
0
                                       op[0], op[1], op[2], op[3]);
5390
0
                                printf ("  srcb = 0x%x,", srcb);
5391
0
                                printf ("  rdst = 0x%x,", rdst);
5392
0
                                printf ("  srca = 0x%x\n", srca);
5393
0
                              }
5394
2.09k
                            SYNTAX("dmul  %1, %2, %0");
5395
2.09k
#line 1247 "rx-decode.opc"
5396
2.09k
                            ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397
5398
2.09k
                          }
5399
2.09k
                        break;
5400
3
                    }
5401
2.09k
                  break;
5402
2.09k
                case 0x05:
5403
53
                    GETBYTE ();
5404
53
                    switch (op[3] & 0x00)
5405
53
                    {
5406
53
                      case 0x00:
5407
1.21k
                        op_semantics_39:
5408
1.21k
                          {
5409
                            /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv  %1, %2, %0 */
5410
1.21k
#line 1244 "rx-decode.opc"
5411
1.21k
                            int srcb AU = (op[2] >> 4) & 0x0f;
5412
1.21k
#line 1244 "rx-decode.opc"
5413
1.21k
                            int rdst AU = (op[3] >> 4) & 0x0f;
5414
1.21k
#line 1244 "rx-decode.opc"
5415
1.21k
                            int srca AU = op[3] & 0x0f;
5416
1.21k
                            if (trace)
5417
0
                              {
5418
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5419
0
                                       "/** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv  %1, %2, %0 */",
5420
0
                                       op[0], op[1], op[2], op[3]);
5421
0
                                printf ("  srcb = 0x%x,", srcb);
5422
0
                                printf ("  rdst = 0x%x,", rdst);
5423
0
                                printf ("  srca = 0x%x\n", srca);
5424
0
                              }
5425
1.21k
                            SYNTAX("ddiv  %1, %2, %0");
5426
1.21k
#line 1244 "rx-decode.opc"
5427
1.21k
                            ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428
5429
1.21k
                          }
5430
1.21k
                        break;
5431
53
                    }
5432
1.21k
                  break;
5433
1.21k
                case 0x08:
5434
186
                    GETBYTE ();
5435
186
                    switch (op[3] & 0x00)
5436
186
                    {
5437
186
                      case 0x00:
5438
2.55k
                        op_semantics_40:
5439
2.55k
                          {
5440
                            /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0  %1, %2 */
5441
2.55k
#line 1241 "rx-decode.opc"
5442
2.55k
                            int srcb AU = (op[2] >> 4) & 0x0f;
5443
2.55k
#line 1241 "rx-decode.opc"
5444
2.55k
                            int cond AU = (op[3] >> 4) & 0x0f;
5445
2.55k
#line 1241 "rx-decode.opc"
5446
2.55k
                            int srca AU = op[3] & 0x0f;
5447
2.55k
                            if (trace)
5448
0
                              {
5449
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5450
0
                                       "/** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0  %1, %2 */",
5451
0
                                       op[0], op[1], op[2], op[3]);
5452
0
                                printf ("  srcb = 0x%x,", srcb);
5453
0
                                printf ("  cond = 0x%x,", cond);
5454
0
                                printf ("  srca = 0x%x\n", srca);
5455
0
                              }
5456
2.55k
                            SYNTAX("dcmp%0  %1, %2");
5457
2.55k
#line 1241 "rx-decode.opc"
5458
2.55k
                            ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459
5460
2.55k
                          }
5461
2.55k
                        break;
5462
186
                    }
5463
2.55k
                  break;
5464
2.55k
                case 0x0c:
5465
571
                    GETBYTE ();
5466
571
                    switch (op[3] & 0x0f)
5467
571
                    {
5468
100
                      case 0x00:
5469
1.07k
                        op_semantics_41:
5470
1.07k
                          {
5471
                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d  %1, %0 */
5472
1.07k
#line 1179 "rx-decode.opc"
5473
1.07k
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5474
1.07k
#line 1179 "rx-decode.opc"
5475
1.07k
                            int rdst AU = (op[3] >> 4) & 0x0f;
5476
1.07k
                            if (trace)
5477
0
                              {
5478
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5479
0
                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d  %1, %0 */",
5480
0
                                       op[0], op[1], op[2], op[3]);
5481
0
                                printf ("  rsrc = 0x%x,", rsrc);
5482
0
                                printf ("  rdst = 0x%x\n", rdst);
5483
0
                              }
5484
1.07k
                            SYNTAX("dmov.d  %1, %0");
5485
1.07k
#line 1179 "rx-decode.opc"
5486
1.07k
                            ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487
5488
1.07k
                          }
5489
1.07k
                        break;
5490
373
                      case 0x01:
5491
838
                        op_semantics_42:
5492
838
                          {
5493
                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs  %1, %0 */
5494
838
#line 1235 "rx-decode.opc"
5495
838
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5496
838
#line 1235 "rx-decode.opc"
5497
838
                            int rdst AU = (op[3] >> 4) & 0x0f;
5498
838
                            if (trace)
5499
0
                              {
5500
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5501
0
                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs  %1, %0 */",
5502
0
                                       op[0], op[1], op[2], op[3]);
5503
0
                                printf ("  rsrc = 0x%x,", rsrc);
5504
0
                                printf ("  rdst = 0x%x\n", rdst);
5505
0
                              }
5506
838
                            SYNTAX("dabs  %1, %0");
5507
838
#line 1235 "rx-decode.opc"
5508
838
                            ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509
5510
838
                          }
5511
838
                        break;
5512
10
                      case 0x02:
5513
354
                        op_semantics_43:
5514
354
                          {
5515
                            /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg  %1, %0 */
5516
354
#line 1250 "rx-decode.opc"
5517
354
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5518
354
#line 1250 "rx-decode.opc"
5519
354
                            int rdst AU = (op[3] >> 4) & 0x0f;
5520
354
                            if (trace)
5521
0
                              {
5522
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5523
0
                                       "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg  %1, %0 */",
5524
0
                                       op[0], op[1], op[2], op[3]);
5525
0
                                printf ("  rsrc = 0x%x,", rsrc);
5526
0
                                printf ("  rdst = 0x%x\n", rdst);
5527
0
                              }
5528
354
                            SYNTAX("dneg  %1, %0");
5529
354
#line 1250 "rx-decode.opc"
5530
354
                            ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531
5532
354
                          }
5533
354
                        break;
5534
87
                      default: UNSUPPORTED(); break;
5535
571
                    }
5536
2.35k
                  break;
5537
2.35k
                case 0x0d:
5538
100
                    GETBYTE ();
5539
100
                    switch (op[3] & 0x0f)
5540
100
                    {
5541
50
                      case 0x00:
5542
591
                        op_semantics_44:
5543
591
                          {
5544
                            /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */
5545
591
#line 1256 "rx-decode.opc"
5546
591
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5547
591
#line 1256 "rx-decode.opc"
5548
591
                            int rdst AU = (op[3] >> 4) & 0x0f;
5549
591
                            if (trace)
5550
0
                              {
5551
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5552
0
                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt %1, %0 */",
5553
0
                                       op[0], op[1], op[2], op[3]);
5554
0
                                printf ("  rsrc = 0x%x,", rsrc);
5555
0
                                printf ("  rdst = 0x%x\n", rdst);
5556
0
                              }
5557
591
                            SYNTAX("dsqrt %1, %0");
5558
591
#line 1256 "rx-decode.opc"
5559
591
                            ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560
5561
591
                          }
5562
591
                        break;
5563
2
                      case 0x08:
5564
277
                        op_semantics_45:
5565
277
                          {
5566
                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi  %1, %0 */
5567
277
#line 1265 "rx-decode.opc"
5568
277
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5569
277
#line 1265 "rx-decode.opc"
5570
277
                            int rdst AU = (op[3] >> 4) & 0x0f;
5571
277
                            if (trace)
5572
0
                              {
5573
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5574
0
                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi  %1, %0 */",
5575
0
                                       op[0], op[1], op[2], op[3]);
5576
0
                                printf ("  rsrc = 0x%x,", rsrc);
5577
0
                                printf ("  rdst = 0x%x\n", rdst);
5578
0
                              }
5579
277
                            SYNTAX("dtoi  %1, %0");
5580
277
#line 1265 "rx-decode.opc"
5581
277
                            ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582
5583
277
                          }
5584
277
                        break;
5585
5
                      case 0x09:
5586
528
                        op_semantics_46:
5587
528
                          {
5588
                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou  %1, %0 */
5589
528
#line 1268 "rx-decode.opc"
5590
528
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5591
528
#line 1268 "rx-decode.opc"
5592
528
                            int rdst AU = (op[3] >> 4) & 0x0f;
5593
528
                            if (trace)
5594
0
                              {
5595
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5596
0
                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou  %1, %0 */",
5597
0
                                       op[0], op[1], op[2], op[3]);
5598
0
                                printf ("  rsrc = 0x%x,", rsrc);
5599
0
                                printf ("  rdst = 0x%x\n", rdst);
5600
0
                              }
5601
528
                            SYNTAX("dtou  %1, %0");
5602
528
#line 1268 "rx-decode.opc"
5603
528
                            ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604
5605
528
                          }
5606
528
                        break;
5607
15
                      case 0x0c:
5608
896
                        op_semantics_47:
5609
896
                          {
5610
                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof  %1, %0 */
5611
896
#line 1262 "rx-decode.opc"
5612
896
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5613
896
#line 1262 "rx-decode.opc"
5614
896
                            int rdst AU = (op[3] >> 4) & 0x0f;
5615
896
                            if (trace)
5616
0
                              {
5617
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5618
0
                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof  %1, %0 */",
5619
0
                                       op[0], op[1], op[2], op[3]);
5620
0
                                printf ("  rsrc = 0x%x,", rsrc);
5621
0
                                printf ("  rdst = 0x%x\n", rdst);
5622
0
                              }
5623
896
                            SYNTAX("dtof  %1, %0");
5624
896
#line 1262 "rx-decode.opc"
5625
896
                            ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626
5627
896
                          }
5628
896
                        break;
5629
18
                      case 0x0d:
5630
384
                        op_semantics_48:
5631
384
                          {
5632
                            /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround  %1, %0 */
5633
384
#line 1253 "rx-decode.opc"
5634
384
                            int rsrc AU = (op[2] >> 4) & 0x0f;
5635
384
#line 1253 "rx-decode.opc"
5636
384
                            int rdst AU = (op[3] >> 4) & 0x0f;
5637
384
                            if (trace)
5638
0
                              {
5639
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5640
0
                                       "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround  %1, %0 */",
5641
0
                                       op[0], op[1], op[2], op[3]);
5642
0
                                printf ("  rsrc = 0x%x,", rsrc);
5643
0
                                printf ("  rdst = 0x%x\n", rdst);
5644
0
                              }
5645
384
                            SYNTAX("dround  %1, %0");
5646
384
#line 1253 "rx-decode.opc"
5647
384
                            ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648
5649
384
                          }
5650
384
                        break;
5651
10
                      default: UNSUPPORTED(); break;
5652
100
                    }
5653
2.68k
                  break;
5654
2.68k
                case 0x10:
5655
9
                    GETBYTE ();
5656
9
                    switch (op[3] & 0x00)
5657
9
                    {
5658
9
                      case 0x00:
5659
9
                        goto op_semantics_36;
5660
0
                        break;
5661
9
                    }
5662
0
                  break;
5663
98
                case 0x11:
5664
98
                    GETBYTE ();
5665
98
                    switch (op[3] & 0x00)
5666
98
                    {
5667
98
                      case 0x00:
5668
98
                        goto op_semantics_37;
5669
0
                        break;
5670
98
                    }
5671
0
                  break;
5672
40
                case 0x12:
5673
40
                    GETBYTE ();
5674
40
                    switch (op[3] & 0x00)
5675
40
                    {
5676
40
                      case 0x00:
5677
40
                        goto op_semantics_38;
5678
0
                        break;
5679
40
                    }
5680
0
                  break;
5681
2
                case 0x15:
5682
2
                    GETBYTE ();
5683
2
                    switch (op[3] & 0x00)
5684
2
                    {
5685
2
                      case 0x00:
5686
2
                        goto op_semantics_39;
5687
0
                        break;
5688
2
                    }
5689
0
                  break;
5690
40
                case 0x18:
5691
40
                    GETBYTE ();
5692
40
                    switch (op[3] & 0x00)
5693
40
                    {
5694
40
                      case 0x00:
5695
40
                        goto op_semantics_40;
5696
0
                        break;
5697
40
                    }
5698
0
                  break;
5699
501
                case 0x1c:
5700
501
                    GETBYTE ();
5701
501
                    switch (op[3] & 0x0f)
5702
501
                    {
5703
298
                      case 0x00:
5704
298
                        goto op_semantics_41;
5705
0
                        break;
5706
185
                      case 0x01:
5707
185
                        goto op_semantics_42;
5708
0
                        break;
5709
0
                      case 0x02:
5710
0
                        goto op_semantics_43;
5711
0
                        break;
5712
18
                      default: UNSUPPORTED(); break;
5713
501
                    }
5714
18
                  break;
5715
79
                case 0x1d:
5716
79
                    GETBYTE ();
5717
79
                    switch (op[3] & 0x0f)
5718
79
                    {
5719
1
                      case 0x00:
5720
1
                        goto op_semantics_44;
5721
0
                        break;
5722
36
                      case 0x08:
5723
36
                        goto op_semantics_45;
5724
0
                        break;
5725
9
                      case 0x09:
5726
9
                        goto op_semantics_46;
5727
0
                        break;
5728
0
                      case 0x0c:
5729
0
                        goto op_semantics_47;
5730
0
                        break;
5731
30
                      case 0x0d:
5732
30
                        goto op_semantics_48;
5733
0
                        break;
5734
3
                      default: UNSUPPORTED(); break;
5735
79
                    }
5736
3
                  break;
5737
83
                case 0x20:
5738
83
                    GETBYTE ();
5739
83
                    switch (op[3] & 0x00)
5740
83
                    {
5741
83
                      case 0x00:
5742
83
                        goto op_semantics_36;
5743
0
                        break;
5744
83
                    }
5745
0
                  break;
5746
53
                case 0x21:
5747
53
                    GETBYTE ();
5748
53
                    switch (op[3] & 0x00)
5749
53
                    {
5750
53
                      case 0x00:
5751
53
                        goto op_semantics_37;
5752
0
                        break;
5753
53
                    }
5754
0
                  break;
5755
185
                case 0x22:
5756
185
                    GETBYTE ();
5757
185
                    switch (op[3] & 0x00)
5758
185
                    {
5759
185
                      case 0x00:
5760
185
                        goto op_semantics_38;
5761
0
                        break;
5762
185
                    }
5763
0
                  break;
5764
94
                case 0x25:
5765
94
                    GETBYTE ();
5766
94
                    switch (op[3] & 0x00)
5767
94
                    {
5768
94
                      case 0x00:
5769
94
                        goto op_semantics_39;
5770
0
                        break;
5771
94
                    }
5772
0
                  break;
5773
526
                case 0x28:
5774
526
                    GETBYTE ();
5775
526
                    switch (op[3] & 0x00)
5776
526
                    {
5777
526
                      case 0x00:
5778
526
                        goto op_semantics_40;
5779
0
                        break;
5780
526
                    }
5781
0
                  break;
5782
111
                case 0x2c:
5783
111
                    GETBYTE ();
5784
111
                    switch (op[3] & 0x0f)
5785
111
                    {
5786
11
                      case 0x00:
5787
11
                        goto op_semantics_41;
5788
0
                        break;
5789
2
                      case 0x01:
5790
2
                        goto op_semantics_42;
5791
0
                        break;
5792
7
                      case 0x02:
5793
7
                        goto op_semantics_43;
5794
0
                        break;
5795
90
                      default: UNSUPPORTED(); break;
5796
111
                    }
5797
90
                  break;
5798
419
                case 0x2d:
5799
419
                    GETBYTE ();
5800
419
                    switch (op[3] & 0x0f)
5801
419
                    {
5802
44
                      case 0x00:
5803
44
                        goto op_semantics_44;
5804
0
                        break;
5805
23
                      case 0x08:
5806
23
                        goto op_semantics_45;
5807
0
                        break;
5808
27
                      case 0x09:
5809
27
                        goto op_semantics_46;
5810
0
                        break;
5811
265
                      case 0x0c:
5812
265
                        goto op_semantics_47;
5813
0
                        break;
5814
50
                      case 0x0d:
5815
50
                        goto op_semantics_48;
5816
0
                        break;
5817
10
                      default: UNSUPPORTED(); break;
5818
419
                    }
5819
10
                  break;
5820
10
                case 0x30:
5821
10
                    GETBYTE ();
5822
10
                    switch (op[3] & 0x00)
5823
10
                    {
5824
10
                      case 0x00:
5825
10
                        goto op_semantics_36;
5826
0
                        break;
5827
10
                    }
5828
0
                  break;
5829
23
                case 0x31:
5830
23
                    GETBYTE ();
5831
23
                    switch (op[3] & 0x00)
5832
23
                    {
5833
23
                      case 0x00:
5834
23
                        goto op_semantics_37;
5835
0
                        break;
5836
23
                    }
5837
0
                  break;
5838
61
                case 0x32:
5839
61
                    GETBYTE ();
5840
61
                    switch (op[3] & 0x00)
5841
61
                    {
5842
61
                      case 0x00:
5843
61
                        goto op_semantics_38;
5844
0
                        break;
5845
61
                    }
5846
0
                  break;
5847
65
                case 0x35:
5848
65
                    GETBYTE ();
5849
65
                    switch (op[3] & 0x00)
5850
65
                    {
5851
65
                      case 0x00:
5852
65
                        goto op_semantics_39;
5853
0
                        break;
5854
65
                    }
5855
0
                  break;
5856
89
                case 0x38:
5857
89
                    GETBYTE ();
5858
89
                    switch (op[3] & 0x00)
5859
89
                    {
5860
89
                      case 0x00:
5861
89
                        goto op_semantics_40;
5862
0
                        break;
5863
89
                    }
5864
0
                  break;
5865
206
                case 0x3c:
5866
206
                    GETBYTE ();
5867
206
                    switch (op[3] & 0x0f)
5868
206
                    {
5869
2
                      case 0x00:
5870
2
                        goto op_semantics_41;
5871
0
                        break;
5872
30
                      case 0x01:
5873
30
                        goto op_semantics_42;
5874
0
                        break;
5875
36
                      case 0x02:
5876
36
                        goto op_semantics_43;
5877
0
                        break;
5878
138
                      default: UNSUPPORTED(); break;
5879
206
                    }
5880
138
                  break;
5881
458
                case 0x3d:
5882
458
                    GETBYTE ();
5883
458
                    switch (op[3] & 0x0f)
5884
458
                    {
5885
112
                      case 0x00:
5886
112
                        goto op_semantics_44;
5887
0
                        break;
5888
4
                      case 0x08:
5889
4
                        goto op_semantics_45;
5890
0
                        break;
5891
60
                      case 0x09:
5892
60
                        goto op_semantics_46;
5893
0
                        break;
5894
64
                      case 0x0c:
5895
64
                        goto op_semantics_47;
5896
0
                        break;
5897
13
                      case 0x0d:
5898
13
                        goto op_semantics_48;
5899
0
                        break;
5900
205
                      default: UNSUPPORTED(); break;
5901
458
                    }
5902
205
                  break;
5903
205
                case 0x40:
5904
9
                    GETBYTE ();
5905
9
                    switch (op[3] & 0x00)
5906
9
                    {
5907
9
                      case 0x00:
5908
9
                        goto op_semantics_36;
5909
0
                        break;
5910
9
                    }
5911
0
                  break;
5912
53
                case 0x41:
5913
53
                    GETBYTE ();
5914
53
                    switch (op[3] & 0x00)
5915
53
                    {
5916
53
                      case 0x00:
5917
53
                        goto op_semantics_37;
5918
0
                        break;
5919
53
                    }
5920
0
                  break;
5921
92
                case 0x42:
5922
92
                    GETBYTE ();
5923
92
                    switch (op[3] & 0x00)
5924
92
                    {
5925
92
                      case 0x00:
5926
92
                        goto op_semantics_38;
5927
0
                        break;
5928
92
                    }
5929
0
                  break;
5930
29
                case 0x45:
5931
29
                    GETBYTE ();
5932
29
                    switch (op[3] & 0x00)
5933
29
                    {
5934
29
                      case 0x00:
5935
29
                        goto op_semantics_39;
5936
0
                        break;
5937
29
                    }
5938
0
                  break;
5939
234
                case 0x48:
5940
234
                    GETBYTE ();
5941
234
                    switch (op[3] & 0x00)
5942
234
                    {
5943
234
                      case 0x00:
5944
234
                        goto op_semantics_40;
5945
0
                        break;
5946
234
                    }
5947
0
                  break;
5948
95
                case 0x4c:
5949
95
                    GETBYTE ();
5950
95
                    switch (op[3] & 0x0f)
5951
95
                    {
5952
0
                      case 0x00:
5953
0
                        goto op_semantics_41;
5954
0
                        break;
5955
0
                      case 0x01:
5956
0
                        goto op_semantics_42;
5957
0
                        break;
5958
1
                      case 0x02:
5959
1
                        goto op_semantics_43;
5960
0
                        break;
5961
94
                      default: UNSUPPORTED(); break;
5962
95
                    }
5963
94
                  break;
5964
332
                case 0x4d:
5965
332
                    GETBYTE ();
5966
332
                    switch (op[3] & 0x0f)
5967
332
                    {
5968
1
                      case 0x00:
5969
1
                        goto op_semantics_44;
5970
0
                        break;
5971
2
                      case 0x08:
5972
2
                        goto op_semantics_45;
5973
0
                        break;
5974
154
                      case 0x09:
5975
154
                        goto op_semantics_46;
5976
0
                        break;
5977
30
                      case 0x0c:
5978
30
                        goto op_semantics_47;
5979
0
                        break;
5980
0
                      case 0x0d:
5981
0
                        goto op_semantics_48;
5982
0
                        break;
5983
145
                      default: UNSUPPORTED(); break;
5984
332
                    }
5985
145
                  break;
5986
145
                case 0x50:
5987
78
                    GETBYTE ();
5988
78
                    switch (op[3] & 0x00)
5989
78
                    {
5990
78
                      case 0x00:
5991
78
                        goto op_semantics_36;
5992
0
                        break;
5993
78
                    }
5994
0
                  break;
5995
596
                case 0x51:
5996
596
                    GETBYTE ();
5997
596
                    switch (op[3] & 0x00)
5998
596
                    {
5999
596
                      case 0x00:
6000
596
                        goto op_semantics_37;
6001
0
                        break;
6002
596
                    }
6003
0
                  break;
6004
31
                case 0x52:
6005
31
                    GETBYTE ();
6006
31
                    switch (op[3] & 0x00)
6007
31
                    {
6008
31
                      case 0x00:
6009
31
                        goto op_semantics_38;
6010
0
                        break;
6011
31
                    }
6012
0
                  break;
6013
160
                case 0x55:
6014
160
                    GETBYTE ();
6015
160
                    switch (op[3] & 0x00)
6016
160
                    {
6017
160
                      case 0x00:
6018
160
                        goto op_semantics_39;
6019
0
                        break;
6020
160
                    }
6021
0
                  break;
6022
61
                case 0x58:
6023
61
                    GETBYTE ();
6024
61
                    switch (op[3] & 0x00)
6025
61
                    {
6026
61
                      case 0x00:
6027
61
                        goto op_semantics_40;
6028
0
                        break;
6029
61
                    }
6030
0
                  break;
6031
280
                case 0x5c:
6032
280
                    GETBYTE ();
6033
280
                    switch (op[3] & 0x0f)
6034
280
                    {
6035
111
                      case 0x00:
6036
111
                        goto op_semantics_41;
6037
0
                        break;
6038
117
                      case 0x01:
6039
117
                        goto op_semantics_42;
6040
0
                        break;
6041
49
                      case 0x02:
6042
49
                        goto op_semantics_43;
6043
0
                        break;
6044
3
                      default: UNSUPPORTED(); break;
6045
280
                    }
6046
3
                  break;
6047
215
                case 0x5d:
6048
215
                    GETBYTE ();
6049
215
                    switch (op[3] & 0x0f)
6050
215
                    {
6051
7
                      case 0x00:
6052
7
                        goto op_semantics_44;
6053
0
                        break;
6054
20
                      case 0x08:
6055
20
                        goto op_semantics_45;
6056
0
                        break;
6057
60
                      case 0x09:
6058
60
                        goto op_semantics_46;
6059
0
                        break;
6060
74
                      case 0x0c:
6061
74
                        goto op_semantics_47;
6062
0
                        break;
6063
14
                      case 0x0d:
6064
14
                        goto op_semantics_48;
6065
0
                        break;
6066
40
                      default: UNSUPPORTED(); break;
6067
215
                    }
6068
40
                  break;
6069
40
                case 0x60:
6070
11
                    GETBYTE ();
6071
11
                    switch (op[3] & 0x00)
6072
11
                    {
6073
11
                      case 0x00:
6074
11
                        goto op_semantics_36;
6075
0
                        break;
6076
11
                    }
6077
0
                  break;
6078
8
                case 0x61:
6079
8
                    GETBYTE ();
6080
8
                    switch (op[3] & 0x00)
6081
8
                    {
6082
8
                      case 0x00:
6083
8
                        goto op_semantics_37;
6084
0
                        break;
6085
8
                    }
6086
0
                  break;
6087
63
                case 0x62:
6088
63
                    GETBYTE ();
6089
63
                    switch (op[3] & 0x00)
6090
63
                    {
6091
63
                      case 0x00:
6092
63
                        goto op_semantics_38;
6093
0
                        break;
6094
63
                    }
6095
0
                  break;
6096
55
                case 0x65:
6097
55
                    GETBYTE ();
6098
55
                    switch (op[3] & 0x00)
6099
55
                    {
6100
55
                      case 0x00:
6101
55
                        goto op_semantics_39;
6102
0
                        break;
6103
55
                    }
6104
0
                  break;
6105
363
                case 0x68:
6106
363
                    GETBYTE ();
6107
363
                    switch (op[3] & 0x00)
6108
363
                    {
6109
363
                      case 0x00:
6110
363
                        goto op_semantics_40;
6111
0
                        break;
6112
363
                    }
6113
0
                  break;
6114
4
                case 0x6c:
6115
4
                    GETBYTE ();
6116
4
                    switch (op[3] & 0x0f)
6117
4
                    {
6118
1
                      case 0x00:
6119
1
                        goto op_semantics_41;
6120
0
                        break;
6121
1
                      case 0x01:
6122
1
                        goto op_semantics_42;
6123
0
                        break;
6124
1
                      case 0x02:
6125
1
                        goto op_semantics_43;
6126
0
                        break;
6127
1
                      default: UNSUPPORTED(); break;
6128
4
                    }
6129
1
                  break;
6130
501
                case 0x6d:
6131
501
                    GETBYTE ();
6132
501
                    switch (op[3] & 0x0f)
6133
501
                    {
6134
114
                      case 0x00:
6135
114
                        goto op_semantics_44;
6136
0
                        break;
6137
0
                      case 0x08:
6138
0
                        goto op_semantics_45;
6139
0
                        break;
6140
2
                      case 0x09:
6141
2
                        goto op_semantics_46;
6142
0
                        break;
6143
146
                      case 0x0c:
6144
146
                        goto op_semantics_47;
6145
0
                        break;
6146
114
                      case 0x0d:
6147
114
                        goto op_semantics_48;
6148
0
                        break;
6149
125
                      default: UNSUPPORTED(); break;
6150
501
                    }
6151
125
                  break;
6152
125
                case 0x70:
6153
34
                    GETBYTE ();
6154
34
                    switch (op[3] & 0x00)
6155
34
                    {
6156
34
                      case 0x00:
6157
34
                        goto op_semantics_36;
6158
0
                        break;
6159
34
                    }
6160
0
                  break;
6161
1
                case 0x71:
6162
1
                    GETBYTE ();
6163
1
                    switch (op[3] & 0x00)
6164
1
                    {
6165
1
                      case 0x00:
6166
1
                        goto op_semantics_37;
6167
0
                        break;
6168
1
                    }
6169
0
                  break;
6170
64
                case 0x72:
6171
64
                    GETBYTE ();
6172
64
                    switch (op[3] & 0x00)
6173
64
                    {
6174
64
                      case 0x00:
6175
64
                        goto op_semantics_38;
6176
0
                        break;
6177
64
                    }
6178
0
                  break;
6179
62
                case 0x75:
6180
62
                    GETBYTE ();
6181
62
                    switch (op[3] & 0x00)
6182
62
                    {
6183
62
                      case 0x00:
6184
62
                        goto op_semantics_39;
6185
0
                        break;
6186
62
                    }
6187
0
                  break;
6188
56
                case 0x78:
6189
56
                    GETBYTE ();
6190
56
                    switch (op[3] & 0x00)
6191
56
                    {
6192
45
                      case 0x00:
6193
45
                        goto op_semantics_40;
6194
0
                        break;
6195
56
                    }
6196
0
                  break;
6197
74
                case 0x7c:
6198
74
                    GETBYTE ();
6199
74
                    switch (op[3] & 0x0f)
6200
74
                    {
6201
35
                      case 0x00:
6202
35
                        goto op_semantics_41;
6203
0
                        break;
6204
5
                      case 0x01:
6205
5
                        goto op_semantics_42;
6206
0
                        break;
6207
8
                      case 0x02:
6208
8
                        goto op_semantics_43;
6209
0
                        break;
6210
26
                      default: UNSUPPORTED(); break;
6211
74
                    }
6212
26
                  break;
6213
265
                case 0x7d:
6214
265
                    GETBYTE ();
6215
265
                    switch (op[3] & 0x0f)
6216
265
                    {
6217
21
                      case 0x00:
6218
21
                        goto op_semantics_44;
6219
0
                        break;
6220
37
                      case 0x08:
6221
37
                        goto op_semantics_45;
6222
0
                        break;
6223
101
                      case 0x09:
6224
101
                        goto op_semantics_46;
6225
0
                        break;
6226
0
                      case 0x0c:
6227
0
                        goto op_semantics_47;
6228
0
                        break;
6229
46
                      case 0x0d:
6230
46
                        goto op_semantics_48;
6231
0
                        break;
6232
60
                      default: UNSUPPORTED(); break;
6233
265
                    }
6234
60
                  break;
6235
60
                case 0x80:
6236
49
                    GETBYTE ();
6237
49
                    switch (op[3] & 0x00)
6238
49
                    {
6239
49
                      case 0x00:
6240
49
                        goto op_semantics_36;
6241
0
                        break;
6242
49
                    }
6243
0
                  break;
6244
132
                case 0x81:
6245
132
                    GETBYTE ();
6246
132
                    switch (op[3] & 0x00)
6247
132
                    {
6248
132
                      case 0x00:
6249
132
                        goto op_semantics_37;
6250
0
                        break;
6251
132
                    }
6252
0
                  break;
6253
269
                case 0x82:
6254
269
                    GETBYTE ();
6255
269
                    switch (op[3] & 0x00)
6256
269
                    {
6257
269
                      case 0x00:
6258
269
                        goto op_semantics_38;
6259
0
                        break;
6260
269
                    }
6261
0
                  break;
6262
11
                case 0x85:
6263
11
                    GETBYTE ();
6264
11
                    switch (op[3] & 0x00)
6265
11
                    {
6266
7
                      case 0x00:
6267
7
                        goto op_semantics_39;
6268
0
                        break;
6269
11
                    }
6270
0
                  break;
6271
593
                case 0x88:
6272
593
                    GETBYTE ();
6273
593
                    switch (op[3] & 0x00)
6274
593
                    {
6275
593
                      case 0x00:
6276
593
                        goto op_semantics_40;
6277
0
                        break;
6278
593
                    }
6279
0
                  break;
6280
390
                case 0x8c:
6281
390
                    GETBYTE ();
6282
390
                    switch (op[3] & 0x0f)
6283
390
                    {
6284
22
                      case 0x00:
6285
22
                        goto op_semantics_41;
6286
0
                        break;
6287
12
                      case 0x01:
6288
12
                        goto op_semantics_42;
6289
0
                        break;
6290
26
                      case 0x02:
6291
26
                        goto op_semantics_43;
6292
0
                        break;
6293
330
                      default: UNSUPPORTED(); break;
6294
390
                    }
6295
330
                  break;
6296
434
                case 0x8d:
6297
434
                    GETBYTE ();
6298
434
                    switch (op[3] & 0x0f)
6299
434
                    {
6300
133
                      case 0x00:
6301
133
                        goto op_semantics_44;
6302
0
                        break;
6303
0
                      case 0x08:
6304
0
                        goto op_semantics_45;
6305
0
                        break;
6306
1
                      case 0x09:
6307
1
                        goto op_semantics_46;
6308
0
                        break;
6309
0
                      case 0x0c:
6310
0
                        goto op_semantics_47;
6311
0
                        break;
6312
3
                      case 0x0d:
6313
3
                        goto op_semantics_48;
6314
0
                        break;
6315
297
                      default: UNSUPPORTED(); break;
6316
434
                    }
6317
297
                  break;
6318
297
                case 0x90:
6319
57
                    GETBYTE ();
6320
57
                    switch (op[3] & 0x00)
6321
57
                    {
6322
57
                      case 0x00:
6323
57
                        goto op_semantics_36;
6324
0
                        break;
6325
57
                    }
6326
0
                  break;
6327
170
                case 0x91:
6328
170
                    GETBYTE ();
6329
170
                    switch (op[3] & 0x00)
6330
170
                    {
6331
170
                      case 0x00:
6332
170
                        goto op_semantics_37;
6333
0
                        break;
6334
170
                    }
6335
0
                  break;
6336
61
                case 0x92:
6337
61
                    GETBYTE ();
6338
61
                    switch (op[3] & 0x00)
6339
61
                    {
6340
61
                      case 0x00:
6341
61
                        goto op_semantics_38;
6342
0
                        break;
6343
61
                    }
6344
0
                  break;
6345
184
                case 0x95:
6346
184
                    GETBYTE ();
6347
184
                    switch (op[3] & 0x00)
6348
184
                    {
6349
184
                      case 0x00:
6350
184
                        goto op_semantics_39;
6351
0
                        break;
6352
184
                    }
6353
0
                  break;
6354
0
                case 0x98:
6355
0
                    GETBYTE ();
6356
0
                    switch (op[3] & 0x00)
6357
0
                    {
6358
0
                      case 0x00:
6359
0
                        goto op_semantics_40;
6360
0
                        break;
6361
0
                    }
6362
0
                  break;
6363
213
                case 0x9c:
6364
213
                    GETBYTE ();
6365
213
                    switch (op[3] & 0x0f)
6366
213
                    {
6367
83
                      case 0x00:
6368
83
                        goto op_semantics_41;
6369
0
                        break;
6370
2
                      case 0x01:
6371
2
                        goto op_semantics_42;
6372
0
                        break;
6373
12
                      case 0x02:
6374
12
                        goto op_semantics_43;
6375
0
                        break;
6376
116
                      default: UNSUPPORTED(); break;
6377
213
                    }
6378
116
                  break;
6379
116
                case 0x9d:
6380
100
                    GETBYTE ();
6381
100
                    switch (op[3] & 0x0f)
6382
100
                    {
6383
26
                      case 0x00:
6384
26
                        goto op_semantics_44;
6385
0
                        break;
6386
0
                      case 0x08:
6387
0
                        goto op_semantics_45;
6388
0
                        break;
6389
9
                      case 0x09:
6390
9
                        goto op_semantics_46;
6391
0
                        break;
6392
49
                      case 0x0c:
6393
49
                        goto op_semantics_47;
6394
0
                        break;
6395
3
                      case 0x0d:
6396
3
                        goto op_semantics_48;
6397
0
                        break;
6398
13
                      default: UNSUPPORTED(); break;
6399
100
                    }
6400
13
                  break;
6401
33
                case 0xa0:
6402
33
                    GETBYTE ();
6403
33
                    switch (op[3] & 0x00)
6404
33
                    {
6405
33
                      case 0x00:
6406
33
                        goto op_semantics_36;
6407
0
                        break;
6408
33
                    }
6409
0
                  break;
6410
51
                case 0xa1:
6411
51
                    GETBYTE ();
6412
51
                    switch (op[3] & 0x00)
6413
51
                    {
6414
51
                      case 0x00:
6415
51
                        goto op_semantics_37;
6416
0
                        break;
6417
51
                    }
6418
0
                  break;
6419
23
                case 0xa2:
6420
23
                    GETBYTE ();
6421
23
                    switch (op[3] & 0x00)
6422
23
                    {
6423
23
                      case 0x00:
6424
23
                        goto op_semantics_38;
6425
0
                        break;
6426
23
                    }
6427
0
                  break;
6428
3
                case 0xa5:
6429
3
                    GETBYTE ();
6430
3
                    switch (op[3] & 0x00)
6431
3
                    {
6432
3
                      case 0x00:
6433
3
                        goto op_semantics_39;
6434
0
                        break;
6435
3
                    }
6436
0
                  break;
6437
226
                case 0xa8:
6438
226
                    GETBYTE ();
6439
226
                    switch (op[3] & 0x00)
6440
226
                    {
6441
226
                      case 0x00:
6442
226
                        goto op_semantics_40;
6443
0
                        break;
6444
226
                    }
6445
0
                  break;
6446
84
                case 0xac:
6447
84
                    GETBYTE ();
6448
84
                    switch (op[3] & 0x0f)
6449
84
                    {
6450
75
                      case 0x00:
6451
75
                        goto op_semantics_41;
6452
0
                        break;
6453
0
                      case 0x01:
6454
0
                        goto op_semantics_42;
6455
0
                        break;
6456
3
                      case 0x02:
6457
3
                        goto op_semantics_43;
6458
0
                        break;
6459
6
                      default: UNSUPPORTED(); break;
6460
84
                    }
6461
6
                  break;
6462
118
                case 0xad:
6463
118
                    GETBYTE ();
6464
118
                    switch (op[3] & 0x0f)
6465
118
                    {
6466
13
                      case 0x00:
6467
13
                        goto op_semantics_44;
6468
0
                        break;
6469
2
                      case 0x08:
6470
2
                        goto op_semantics_45;
6471
0
                        break;
6472
8
                      case 0x09:
6473
8
                        goto op_semantics_46;
6474
0
                        break;
6475
49
                      case 0x0c:
6476
49
                        goto op_semantics_47;
6477
0
                        break;
6478
1
                      case 0x0d:
6479
1
                        goto op_semantics_48;
6480
0
                        break;
6481
45
                      default: UNSUPPORTED(); break;
6482
118
                    }
6483
45
                  break;
6484
45
                case 0xb0:
6485
1
                    GETBYTE ();
6486
1
                    switch (op[3] & 0x00)
6487
1
                    {
6488
1
                      case 0x00:
6489
1
                        goto op_semantics_36;
6490
0
                        break;
6491
1
                    }
6492
0
                  break;
6493
544
                case 0xb1:
6494
544
                    GETBYTE ();
6495
544
                    switch (op[3] & 0x00)
6496
544
                    {
6497
544
                      case 0x00:
6498
544
                        goto op_semantics_37;
6499
0
                        break;
6500
544
                    }
6501
0
                  break;
6502
7
                case 0xb2:
6503
7
                    GETBYTE ();
6504
7
                    switch (op[3] & 0x00)
6505
7
                    {
6506
7
                      case 0x00:
6507
7
                        goto op_semantics_38;
6508
0
                        break;
6509
7
                    }
6510
0
                  break;
6511
364
                case 0xb5:
6512
364
                    GETBYTE ();
6513
364
                    switch (op[3] & 0x00)
6514
364
                    {
6515
364
                      case 0x00:
6516
364
                        goto op_semantics_39;
6517
0
                        break;
6518
364
                    }
6519
0
                  break;
6520
15
                case 0xb8:
6521
15
                    GETBYTE ();
6522
15
                    switch (op[3] & 0x00)
6523
15
                    {
6524
15
                      case 0x00:
6525
15
                        goto op_semantics_40;
6526
0
                        break;
6527
15
                    }
6528
0
                  break;
6529
96
                case 0xbc:
6530
96
                    GETBYTE ();
6531
96
                    switch (op[3] & 0x0f)
6532
96
                    {
6533
53
                      case 0x00:
6534
53
                        goto op_semantics_41;
6535
0
                        break;
6536
21
                      case 0x01:
6537
21
                        goto op_semantics_42;
6538
0
                        break;
6539
8
                      case 0x02:
6540
8
                        goto op_semantics_43;
6541
0
                        break;
6542
14
                      default: UNSUPPORTED(); break;
6543
96
                    }
6544
14
                  break;
6545
172
                case 0xbd:
6546
172
                    GETBYTE ();
6547
172
                    switch (op[3] & 0x0f)
6548
172
                    {
6549
4
                      case 0x00:
6550
4
                        goto op_semantics_44;
6551
0
                        break;
6552
7
                      case 0x08:
6553
7
                        goto op_semantics_45;
6554
0
                        break;
6555
0
                      case 0x09:
6556
0
                        goto op_semantics_46;
6557
0
                        break;
6558
83
                      case 0x0c:
6559
83
                        goto op_semantics_47;
6560
0
                        break;
6561
14
                      case 0x0d:
6562
14
                        goto op_semantics_48;
6563
0
                        break;
6564
64
                      default: UNSUPPORTED(); break;
6565
172
                    }
6566
64
                  break;
6567
264
                case 0xc0:
6568
264
                    GETBYTE ();
6569
264
                    switch (op[3] & 0x00)
6570
264
                    {
6571
264
                      case 0x00:
6572
264
                        goto op_semantics_36;
6573
0
                        break;
6574
264
                    }
6575
0
                  break;
6576
89
                case 0xc1:
6577
89
                    GETBYTE ();
6578
89
                    switch (op[3] & 0x00)
6579
89
                    {
6580
89
                      case 0x00:
6581
89
                        goto op_semantics_37;
6582
0
                        break;
6583
89
                    }
6584
0
                  break;
6585
138
                case 0xc2:
6586
138
                    GETBYTE ();
6587
138
                    switch (op[3] & 0x00)
6588
138
                    {
6589
138
                      case 0x00:
6590
138
                        goto op_semantics_38;
6591
0
                        break;
6592
138
                    }
6593
0
                  break;
6594
21
                case 0xc5:
6595
21
                    GETBYTE ();
6596
21
                    switch (op[3] & 0x00)
6597
21
                    {
6598
15
                      case 0x00:
6599
15
                        goto op_semantics_39;
6600
0
                        break;
6601
21
                    }
6602
0
                  break;
6603
66
                case 0xc8:
6604
66
                    GETBYTE ();
6605
66
                    switch (op[3] & 0x00)
6606
66
                    {
6607
66
                      case 0x00:
6608
66
                        goto op_semantics_40;
6609
0
                        break;
6610
66
                    }
6611
0
                  break;
6612
104
                case 0xcc:
6613
104
                    GETBYTE ();
6614
104
                    switch (op[3] & 0x0f)
6615
104
                    {
6616
0
                      case 0x00:
6617
0
                        goto op_semantics_41;
6618
0
                        break;
6619
26
                      case 0x01:
6620
26
                        goto op_semantics_42;
6621
0
                        break;
6622
62
                      case 0x02:
6623
62
                        goto op_semantics_43;
6624
0
                        break;
6625
16
                      default: UNSUPPORTED(); break;
6626
104
                    }
6627
16
                  break;
6628
580
                case 0xcd:
6629
580
                    GETBYTE ();
6630
580
                    switch (op[3] & 0x0f)
6631
580
                    {
6632
21
                      case 0x00:
6633
21
                        goto op_semantics_44;
6634
0
                        break;
6635
12
                      case 0x08:
6636
12
                        goto op_semantics_45;
6637
0
                        break;
6638
48
                      case 0x09:
6639
48
                        goto op_semantics_46;
6640
0
                        break;
6641
0
                      case 0x0c:
6642
0
                        goto op_semantics_47;
6643
0
                        break;
6644
30
                      case 0x0d:
6645
30
                        goto op_semantics_48;
6646
0
                        break;
6647
469
                      default: UNSUPPORTED(); break;
6648
580
                    }
6649
469
                  break;
6650
469
                case 0xd0:
6651
72
                    GETBYTE ();
6652
72
                    switch (op[3] & 0x00)
6653
72
                    {
6654
72
                      case 0x00:
6655
72
                        goto op_semantics_36;
6656
0
                        break;
6657
72
                    }
6658
0
                  break;
6659
48
                case 0xd1:
6660
48
                    GETBYTE ();
6661
48
                    switch (op[3] & 0x00)
6662
48
                    {
6663
48
                      case 0x00:
6664
48
                        goto op_semantics_37;
6665
0
                        break;
6666
48
                    }
6667
0
                  break;
6668
748
                case 0xd2:
6669
748
                    GETBYTE ();
6670
748
                    switch (op[3] & 0x00)
6671
748
                    {
6672
748
                      case 0x00:
6673
748
                        goto op_semantics_38;
6674
0
                        break;
6675
748
                    }
6676
0
                  break;
6677
72
                case 0xd5:
6678
72
                    GETBYTE ();
6679
72
                    switch (op[3] & 0x00)
6680
72
                    {
6681
72
                      case 0x00:
6682
72
                        goto op_semantics_39;
6683
0
                        break;
6684
72
                    }
6685
0
                  break;
6686
58
                case 0xd8:
6687
58
                    GETBYTE ();
6688
58
                    switch (op[3] & 0x00)
6689
58
                    {
6690
58
                      case 0x00:
6691
58
                        goto op_semantics_40;
6692
0
                        break;
6693
58
                    }
6694
0
                  break;
6695
118
                case 0xdc:
6696
118
                    GETBYTE ();
6697
118
                    switch (op[3] & 0x0f)
6698
118
                    {
6699
18
                      case 0x00:
6700
18
                        goto op_semantics_41;
6701
0
                        break;
6702
2
                      case 0x01:
6703
2
                        goto op_semantics_42;
6704
0
                        break;
6705
28
                      case 0x02:
6706
28
                        goto op_semantics_43;
6707
0
                        break;
6708
58
                      default: UNSUPPORTED(); break;
6709
118
                    }
6710
58
                  break;
6711
215
                case 0xdd:
6712
215
                    GETBYTE ();
6713
215
                    switch (op[3] & 0x0f)
6714
215
                    {
6715
32
                      case 0x00:
6716
32
                        goto op_semantics_44;
6717
0
                        break;
6718
0
                      case 0x08:
6719
0
                        goto op_semantics_45;
6720
0
                        break;
6721
34
                      case 0x09:
6722
34
                        goto op_semantics_46;
6723
0
                        break;
6724
86
                      case 0x0c:
6725
86
                        goto op_semantics_47;
6726
0
                        break;
6727
27
                      case 0x0d:
6728
27
                        goto op_semantics_48;
6729
0
                        break;
6730
36
                      default: UNSUPPORTED(); break;
6731
215
                    }
6732
36
                  break;
6733
103
                case 0xe0:
6734
103
                    GETBYTE ();
6735
103
                    switch (op[3] & 0x00)
6736
103
                    {
6737
103
                      case 0x00:
6738
103
                        goto op_semantics_36;
6739
0
                        break;
6740
103
                    }
6741
0
                  break;
6742
118
                case 0xe1:
6743
118
                    GETBYTE ();
6744
118
                    switch (op[3] & 0x00)
6745
118
                    {
6746
118
                      case 0x00:
6747
118
                        goto op_semantics_37;
6748
0
                        break;
6749
118
                    }
6750
0
                  break;
6751
25
                case 0xe2:
6752
25
                    GETBYTE ();
6753
25
                    switch (op[3] & 0x00)
6754
25
                    {
6755
25
                      case 0x00:
6756
25
                        goto op_semantics_38;
6757
0
                        break;
6758
25
                    }
6759
0
                  break;
6760
37
                case 0xe5:
6761
37
                    GETBYTE ();
6762
37
                    switch (op[3] & 0x00)
6763
37
                    {
6764
37
                      case 0x00:
6765
37
                        goto op_semantics_39;
6766
0
                        break;
6767
37
                    }
6768
0
                  break;
6769
49
                case 0xe8:
6770
49
                    GETBYTE ();
6771
49
                    switch (op[3] & 0x00)
6772
49
                    {
6773
49
                      case 0x00:
6774
49
                        goto op_semantics_40;
6775
0
                        break;
6776
49
                    }
6777
0
                  break;
6778
294
                case 0xec:
6779
294
                    GETBYTE ();
6780
294
                    switch (op[3] & 0x0f)
6781
294
                    {
6782
128
                      case 0x00:
6783
128
                        goto op_semantics_41;
6784
0
                        break;
6785
26
                      case 0x01:
6786
26
                        goto op_semantics_42;
6787
0
                        break;
6788
55
                      case 0x02:
6789
55
                        goto op_semantics_43;
6790
0
                        break;
6791
85
                      default: UNSUPPORTED(); break;
6792
294
                    }
6793
85
                  break;
6794
471
                case 0xed:
6795
471
                    GETBYTE ();
6796
471
                    switch (op[3] & 0x0f)
6797
471
                    {
6798
12
                      case 0x00:
6799
12
                        goto op_semantics_44;
6800
0
                        break;
6801
129
                      case 0x08:
6802
129
                        goto op_semantics_45;
6803
0
                        break;
6804
6
                      case 0x09:
6805
6
                        goto op_semantics_46;
6806
0
                        break;
6807
35
                      case 0x0c:
6808
35
                        goto op_semantics_47;
6809
0
                        break;
6810
20
                      case 0x0d:
6811
20
                        goto op_semantics_48;
6812
0
                        break;
6813
269
                      default: UNSUPPORTED(); break;
6814
471
                    }
6815
269
                  break;
6816
269
                case 0xf0:
6817
100
                    GETBYTE ();
6818
100
                    switch (op[3] & 0x00)
6819
100
                    {
6820
100
                      case 0x00:
6821
100
                        goto op_semantics_36;
6822
0
                        break;
6823
100
                    }
6824
0
                  break;
6825
3
                case 0xf1:
6826
3
                    GETBYTE ();
6827
3
                    switch (op[3] & 0x00)
6828
3
                    {
6829
3
                      case 0x00:
6830
3
                        goto op_semantics_37;
6831
0
                        break;
6832
3
                    }
6833
0
                  break;
6834
290
                case 0xf2:
6835
290
                    GETBYTE ();
6836
290
                    switch (op[3] & 0x00)
6837
290
                    {
6838
289
                      case 0x00:
6839
289
                        goto op_semantics_38;
6840
0
                        break;
6841
290
                    }
6842
0
                  break;
6843
10
                case 0xf5:
6844
10
                    GETBYTE ();
6845
10
                    switch (op[3] & 0x00)
6846
10
                    {
6847
10
                      case 0x00:
6848
10
                        goto op_semantics_39;
6849
0
                        break;
6850
10
                    }
6851
0
                  break;
6852
1
                case 0xf8:
6853
1
                    GETBYTE ();
6854
1
                    switch (op[3] & 0x00)
6855
1
                    {
6856
1
                      case 0x00:
6857
1
                        goto op_semantics_40;
6858
0
                        break;
6859
1
                    }
6860
0
                  break;
6861
228
                case 0xfc:
6862
228
                    GETBYTE ();
6863
228
                    switch (op[3] & 0x0f)
6864
228
                    {
6865
139
                      case 0x00:
6866
139
                        goto op_semantics_41;
6867
0
                        break;
6868
36
                      case 0x01:
6869
36
                        goto op_semantics_42;
6870
0
                        break;
6871
48
                      case 0x02:
6872
48
                        goto op_semantics_43;
6873
0
                        break;
6874
5
                      default: UNSUPPORTED(); break;
6875
228
                    }
6876
5
                  break;
6877
16
                case 0xfd:
6878
16
                    GETBYTE ();
6879
16
                    switch (op[3] & 0x0f)
6880
16
                    {
6881
0
                      case 0x00:
6882
0
                        goto op_semantics_44;
6883
0
                        break;
6884
3
                      case 0x08:
6885
3
                        goto op_semantics_45;
6886
0
                        break;
6887
4
                      case 0x09:
6888
4
                        goto op_semantics_46;
6889
0
                        break;
6890
0
                      case 0x0c:
6891
0
                        goto op_semantics_47;
6892
0
                        break;
6893
1
                      case 0x0d:
6894
1
                        goto op_semantics_48;
6895
0
                        break;
6896
8
                      default: UNSUPPORTED(); break;
6897
16
                    }
6898
8
                  break;
6899
2.22k
                default: UNSUPPORTED(); break;
6900
19.3k
              }
6901
19.3k
            break;
6902
39.8k
          default: UNSUPPORTED(); break;
6903
74.5k
        }
6904
59.1k
      break;
6905
59.1k
    case 0x77:
6906
33.1k
        GETBYTE ();
6907
33.1k
        switch (op[1] & 0xf0)
6908
33.1k
        {
6909
4.50k
          case 0x00:
6910
4.50k
            goto op_semantics_32;
6911
0
            break;
6912
1.41k
          case 0x10:
6913
1.41k
            goto op_semantics_33;
6914
0
            break;
6915
2.31k
          case 0x20:
6916
2.31k
            goto op_semantics_34;
6917
0
            break;
6918
1.75k
          case 0x30:
6919
1.75k
            goto op_semantics_35;
6920
0
            break;
6921
23.1k
          default: UNSUPPORTED(); break;
6922
33.1k
        }
6923
23.1k
      break;
6924
33.0k
    case 0x78:
6925
33.0k
        GETBYTE ();
6926
33.0k
        switch (op[1] & 0x00)
6927
33.0k
        {
6928
33.0k
          case 0x00:
6929
60.8k
            op_semantics_49:
6930
60.8k
              {
6931
                /** 0111 100b ittt rdst     bset  #%1, %0 */
6932
60.8k
#line 968 "rx-decode.opc"
6933
60.8k
                int b AU = op[0] & 0x01;
6934
60.8k
#line 968 "rx-decode.opc"
6935
60.8k
                int ittt AU = (op[1] >> 4) & 0x0f;
6936
60.8k
#line 968 "rx-decode.opc"
6937
60.8k
                int rdst AU = op[1] & 0x0f;
6938
60.8k
                if (trace)
6939
0
                  {
6940
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
6941
0
                           "/** 0111 100b ittt rdst     bset  #%1, %0 */",
6942
0
                           op[0], op[1]);
6943
0
                    printf ("  b = 0x%x,", b);
6944
0
                    printf ("  ittt = 0x%x,", ittt);
6945
0
                    printf ("  rdst = 0x%x\n", rdst);
6946
0
                  }
6947
60.8k
                SYNTAX("bset  #%1, %0");
6948
60.8k
#line 968 "rx-decode.opc"
6949
60.8k
                ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950
6951
6952
60.8k
              }
6953
60.8k
            break;
6954
33.0k
        }
6955
60.8k
      break;
6956
60.8k
    case 0x79:
6957
27.8k
        GETBYTE ();
6958
27.8k
        switch (op[1] & 0x00)
6959
27.8k
        {
6960
27.8k
          case 0x00:
6961
27.8k
            goto op_semantics_49;
6962
0
            break;
6963
27.8k
        }
6964
0
      break;
6965
22.1k
    case 0x7a:
6966
22.1k
        GETBYTE ();
6967
22.1k
        switch (op[1] & 0x00)
6968
22.1k
        {
6969
22.1k
          case 0x00:
6970
40.2k
            op_semantics_50:
6971
40.2k
              {
6972
                /** 0111 101b ittt rdst     bclr  #%1, %0 */
6973
40.2k
#line 980 "rx-decode.opc"
6974
40.2k
                int b AU = op[0] & 0x01;
6975
40.2k
#line 980 "rx-decode.opc"
6976
40.2k
                int ittt AU = (op[1] >> 4) & 0x0f;
6977
40.2k
#line 980 "rx-decode.opc"
6978
40.2k
                int rdst AU = op[1] & 0x0f;
6979
40.2k
                if (trace)
6980
0
                  {
6981
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
6982
0
                           "/** 0111 101b ittt rdst     bclr  #%1, %0 */",
6983
0
                           op[0], op[1]);
6984
0
                    printf ("  b = 0x%x,", b);
6985
0
                    printf ("  ittt = 0x%x,", ittt);
6986
0
                    printf ("  rdst = 0x%x\n", rdst);
6987
0
                  }
6988
40.2k
                SYNTAX("bclr  #%1, %0");
6989
40.2k
#line 980 "rx-decode.opc"
6990
40.2k
                ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991
6992
6993
40.2k
              }
6994
40.2k
            break;
6995
22.1k
        }
6996
40.2k
      break;
6997
40.2k
    case 0x7b:
6998
18.1k
        GETBYTE ();
6999
18.1k
        switch (op[1] & 0x00)
7000
18.1k
        {
7001
18.1k
          case 0x00:
7002
18.1k
            goto op_semantics_50;
7003
0
            break;
7004
18.1k
        }
7005
0
      break;
7006
26.7k
    case 0x7c:
7007
26.7k
        GETBYTE ();
7008
26.7k
        switch (op[1] & 0x00)
7009
26.7k
        {
7010
26.7k
          case 0x00:
7011
50.0k
            op_semantics_51:
7012
50.0k
              {
7013
                /** 0111 110b ittt rdst     btst  #%2, %1 */
7014
50.0k
#line 992 "rx-decode.opc"
7015
50.0k
                int b AU = op[0] & 0x01;
7016
50.0k
#line 992 "rx-decode.opc"
7017
50.0k
                int ittt AU = (op[1] >> 4) & 0x0f;
7018
50.0k
#line 992 "rx-decode.opc"
7019
50.0k
                int rdst AU = op[1] & 0x0f;
7020
50.0k
                if (trace)
7021
0
                  {
7022
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7023
0
                           "/** 0111 110b ittt rdst     btst  #%2, %1 */",
7024
0
                           op[0], op[1]);
7025
0
                    printf ("  b = 0x%x,", b);
7026
0
                    printf ("  ittt = 0x%x,", ittt);
7027
0
                    printf ("  rdst = 0x%x\n", rdst);
7028
0
                  }
7029
50.0k
                SYNTAX("btst  #%2, %1");
7030
50.0k
#line 992 "rx-decode.opc"
7031
50.0k
                ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032
7033
7034
50.0k
              }
7035
50.0k
            break;
7036
26.7k
        }
7037
50.0k
      break;
7038
50.0k
    case 0x7d:
7039
23.3k
        GETBYTE ();
7040
23.3k
        switch (op[1] & 0x00)
7041
23.3k
        {
7042
23.3k
          case 0x00:
7043
23.3k
            goto op_semantics_51;
7044
0
            break;
7045
23.3k
        }
7046
0
      break;
7047
31.7k
    case 0x7e:
7048
31.7k
        GETBYTE ();
7049
31.7k
        switch (op[1] & 0xf0)
7050
31.7k
        {
7051
7.19k
          case 0x00:
7052
7.19k
              {
7053
                /** 0111 1110 0000 rdst     not %0 */
7054
7.19k
#line 483 "rx-decode.opc"
7055
7.19k
                int rdst AU = op[1] & 0x0f;
7056
7.19k
                if (trace)
7057
0
                  {
7058
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7059
0
                           "/** 0111 1110 0000 rdst     not %0 */",
7060
0
                           op[0], op[1]);
7061
0
                    printf ("  rdst = 0x%x\n", rdst);
7062
0
                  }
7063
7.19k
                SYNTAX("not %0");
7064
7.19k
#line 483 "rx-decode.opc"
7065
7.19k
                ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066
7067
7.19k
              }
7068
7.19k
            break;
7069
1.17k
          case 0x10:
7070
1.17k
              {
7071
                /** 0111 1110 0001 rdst     neg %0 */
7072
1.17k
#line 504 "rx-decode.opc"
7073
1.17k
                int rdst AU = op[1] & 0x0f;
7074
1.17k
                if (trace)
7075
0
                  {
7076
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7077
0
                           "/** 0111 1110 0001 rdst     neg %0 */",
7078
0
                           op[0], op[1]);
7079
0
                    printf ("  rdst = 0x%x\n", rdst);
7080
0
                  }
7081
1.17k
                SYNTAX("neg %0");
7082
1.17k
#line 504 "rx-decode.opc"
7083
1.17k
                ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084
7085
1.17k
              }
7086
1.17k
            break;
7087
2.57k
          case 0x20:
7088
2.57k
              {
7089
                /** 0111 1110 0010 rdst     abs %0 */
7090
2.57k
#line 586 "rx-decode.opc"
7091
2.57k
                int rdst AU = op[1] & 0x0f;
7092
2.57k
                if (trace)
7093
0
                  {
7094
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7095
0
                           "/** 0111 1110 0010 rdst     abs %0 */",
7096
0
                           op[0], op[1]);
7097
0
                    printf ("  rdst = 0x%x\n", rdst);
7098
0
                  }
7099
2.57k
                SYNTAX("abs %0");
7100
2.57k
#line 586 "rx-decode.opc"
7101
2.57k
                ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102
7103
2.57k
              }
7104
2.57k
            break;
7105
1.64k
          case 0x30:
7106
1.64k
              {
7107
                /** 0111 1110 0011 rdst   sat %0 */
7108
1.64k
#line 906 "rx-decode.opc"
7109
1.64k
                int rdst AU = op[1] & 0x0f;
7110
1.64k
                if (trace)
7111
0
                  {
7112
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7113
0
                           "/** 0111 1110 0011 rdst   sat %0 */",
7114
0
                           op[0], op[1]);
7115
0
                    printf ("  rdst = 0x%x\n", rdst);
7116
0
                  }
7117
1.64k
                SYNTAX("sat %0");
7118
1.64k
#line 906 "rx-decode.opc"
7119
1.64k
                ID(sat); DR (rdst);
7120
7121
1.64k
              }
7122
1.64k
            break;
7123
1.42k
          case 0x40:
7124
1.42k
              {
7125
                /** 0111 1110 0100 rdst     rorc  %0 */
7126
1.42k
#line 766 "rx-decode.opc"
7127
1.42k
                int rdst AU = op[1] & 0x0f;
7128
1.42k
                if (trace)
7129
0
                  {
7130
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7131
0
                           "/** 0111 1110 0100 rdst     rorc  %0 */",
7132
0
                           op[0], op[1]);
7133
0
                    printf ("  rdst = 0x%x\n", rdst);
7134
0
                  }
7135
1.42k
                SYNTAX("rorc  %0");
7136
1.42k
#line 766 "rx-decode.opc"
7137
1.42k
                ID(rorc); DR(rdst); F__SZC;
7138
7139
1.42k
              }
7140
1.42k
            break;
7141
726
          case 0x50:
7142
726
              {
7143
                /** 0111 1110 0101 rdst     rolc  %0 */
7144
726
#line 763 "rx-decode.opc"
7145
726
                int rdst AU = op[1] & 0x0f;
7146
726
                if (trace)
7147
0
                  {
7148
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7149
0
                           "/** 0111 1110 0101 rdst     rolc  %0 */",
7150
0
                           op[0], op[1]);
7151
0
                    printf ("  rdst = 0x%x\n", rdst);
7152
0
                  }
7153
726
                SYNTAX("rolc  %0");
7154
726
#line 763 "rx-decode.opc"
7155
726
                ID(rolc); DR(rdst); F__SZC;
7156
7157
726
              }
7158
726
            break;
7159
847
          case 0x80:
7160
1.87k
          case 0x90:
7161
3.12k
          case 0xa0:
7162
3.12k
              {
7163
                /** 0111 1110 10sz rsrc   push%s  %1 */
7164
3.12k
#line 399 "rx-decode.opc"
7165
3.12k
                int sz AU = (op[1] >> 4) & 0x03;
7166
3.12k
#line 399 "rx-decode.opc"
7167
3.12k
                int rsrc AU = op[1] & 0x0f;
7168
3.12k
                if (trace)
7169
0
                  {
7170
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7171
0
                           "/** 0111 1110 10sz rsrc   push%s  %1 */",
7172
0
                           op[0], op[1]);
7173
0
                    printf ("  sz = 0x%x,", sz);
7174
0
                    printf ("  rsrc = 0x%x\n", rsrc);
7175
0
                  }
7176
3.12k
                SYNTAX("push%s  %1");
7177
3.12k
#line 399 "rx-decode.opc"
7178
3.12k
                ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179
7180
3.12k
              }
7181
3.12k
            break;
7182
670
          case 0xb0:
7183
670
              {
7184
                /** 0111 1110 1011 rdst   pop %0 */
7185
670
#line 396 "rx-decode.opc"
7186
670
                int rdst AU = op[1] & 0x0f;
7187
670
                if (trace)
7188
0
                  {
7189
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7190
0
                           "/** 0111 1110 1011 rdst   pop %0 */",
7191
0
                           op[0], op[1]);
7192
0
                    printf ("  rdst = 0x%x\n", rdst);
7193
0
                  }
7194
670
                SYNTAX("pop %0");
7195
670
#line 396 "rx-decode.opc"
7196
670
                ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197
7198
670
              }
7199
670
            break;
7200
795
          case 0xc0:
7201
2.32k
          case 0xd0:
7202
2.32k
              {
7203
                /** 0111 1110 110 crsrc     pushc %1 */
7204
2.32k
#line 1029 "rx-decode.opc"
7205
2.32k
                int crsrc AU = op[1] & 0x1f;
7206
2.32k
                if (trace)
7207
0
                  {
7208
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7209
0
                           "/** 0111 1110 110 crsrc     pushc %1 */",
7210
0
                           op[0], op[1]);
7211
0
                    printf ("  crsrc = 0x%x\n", crsrc);
7212
0
                  }
7213
2.32k
                SYNTAX("pushc %1");
7214
2.32k
#line 1029 "rx-decode.opc"
7215
2.32k
                ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216
7217
2.32k
              }
7218
2.32k
            break;
7219
1.50k
          case 0xe0:
7220
3.28k
          case 0xf0:
7221
3.28k
              {
7222
                /** 0111 1110 111 crdst     popc  %0 */
7223
3.28k
#line 1026 "rx-decode.opc"
7224
3.28k
                int crdst AU = op[1] & 0x1f;
7225
3.28k
                if (trace)
7226
0
                  {
7227
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7228
0
                           "/** 0111 1110 111 crdst     popc  %0 */",
7229
0
                           op[0], op[1]);
7230
0
                    printf ("  crdst = 0x%x\n", crdst);
7231
0
                  }
7232
3.28k
                SYNTAX("popc  %0");
7233
3.28k
#line 1026 "rx-decode.opc"
7234
3.28k
                ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235
7236
3.28k
              }
7237
3.28k
            break;
7238
7.57k
          default: UNSUPPORTED(); break;
7239
31.7k
        }
7240
31.7k
      break;
7241
74.6k
    case 0x7f:
7242
74.6k
        GETBYTE ();
7243
74.6k
        switch (op[1] & 0xff)
7244
74.6k
        {
7245
6.49k
          case 0x00:
7246
7.68k
          case 0x01:
7247
7.97k
          case 0x02:
7248
8.41k
          case 0x03:
7249
8.49k
          case 0x04:
7250
9.83k
          case 0x05:
7251
10.4k
          case 0x06:
7252
10.7k
          case 0x07:
7253
11.2k
          case 0x08:
7254
11.4k
          case 0x09:
7255
11.5k
          case 0x0a:
7256
11.8k
          case 0x0b:
7257
11.9k
          case 0x0c:
7258
12.6k
          case 0x0d:
7259
12.9k
          case 0x0e:
7260
13.1k
          case 0x0f:
7261
13.1k
              {
7262
                /** 0111 1111 0000 rsrc   jmp %0 */
7263
13.1k
#line 816 "rx-decode.opc"
7264
13.1k
                int rsrc AU = op[1] & 0x0f;
7265
13.1k
                if (trace)
7266
0
                  {
7267
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7268
0
                           "/** 0111 1111 0000 rsrc   jmp %0 */",
7269
0
                           op[0], op[1]);
7270
0
                    printf ("  rsrc = 0x%x\n", rsrc);
7271
0
                  }
7272
13.1k
                SYNTAX("jmp %0");
7273
13.1k
#line 816 "rx-decode.opc"
7274
13.1k
                ID(branch); DR(rsrc);
7275
7276
13.1k
              }
7277
13.1k
            break;
7278
841
          case 0x10:
7279
941
          case 0x11:
7280
1.05k
          case 0x12:
7281
1.27k
          case 0x13:
7282
1.50k
          case 0x14:
7283
1.53k
          case 0x15:
7284
1.59k
          case 0x16:
7285
1.65k
          case 0x17:
7286
1.73k
          case 0x18:
7287
1.84k
          case 0x19:
7288
2.04k
          case 0x1a:
7289
2.10k
          case 0x1b:
7290
2.22k
          case 0x1c:
7291
2.26k
          case 0x1d:
7292
2.28k
          case 0x1e:
7293
2.53k
          case 0x1f:
7294
2.53k
              {
7295
                /** 0111 1111 0001 rsrc   jsr %0 */
7296
2.53k
#line 819 "rx-decode.opc"
7297
2.53k
                int rsrc AU = op[1] & 0x0f;
7298
2.53k
                if (trace)
7299
0
                  {
7300
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7301
0
                           "/** 0111 1111 0001 rsrc   jsr %0 */",
7302
0
                           op[0], op[1]);
7303
0
                    printf ("  rsrc = 0x%x\n", rsrc);
7304
0
                  }
7305
2.53k
                SYNTAX("jsr %0");
7306
2.53k
#line 819 "rx-decode.opc"
7307
2.53k
                ID(jsr); DR(rsrc);
7308
7309
2.53k
              }
7310
2.53k
            break;
7311
84
          case 0x40:
7312
322
          case 0x41:
7313
433
          case 0x42:
7314
652
          case 0x43:
7315
1.14k
          case 0x44:
7316
13.5k
          case 0x45:
7317
13.5k
          case 0x46:
7318
13.7k
          case 0x47:
7319
14.3k
          case 0x48:
7320
14.6k
          case 0x49:
7321
14.6k
          case 0x4a:
7322
14.8k
          case 0x4b:
7323
15.1k
          case 0x4c:
7324
15.3k
          case 0x4d:
7325
15.4k
          case 0x4e:
7326
15.5k
          case 0x4f:
7327
15.5k
              {
7328
                /** 0111 1111 0100 rsrc   bra.l %0 */
7329
15.5k
#line 812 "rx-decode.opc"
7330
15.5k
                int rsrc AU = op[1] & 0x0f;
7331
15.5k
                if (trace)
7332
0
                  {
7333
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7334
0
                           "/** 0111 1111 0100 rsrc   bra.l %0 */",
7335
0
                           op[0], op[1]);
7336
0
                    printf ("  rsrc = 0x%x\n", rsrc);
7337
0
                  }
7338
15.5k
                SYNTAX("bra.l %0");
7339
15.5k
#line 812 "rx-decode.opc"
7340
15.5k
                ID(branchrel); DR(rsrc);
7341
7342
7343
15.5k
              }
7344
15.5k
            break;
7345
33
          case 0x50:
7346
90
          case 0x51:
7347
107
          case 0x52:
7348
174
          case 0x53:
7349
218
          case 0x54:
7350
223
          case 0x55:
7351
353
          case 0x56:
7352
488
          case 0x57:
7353
534
          case 0x58:
7354
712
          case 0x59:
7355
808
          case 0x5a:
7356
923
          case 0x5b:
7357
1.02k
          case 0x5c:
7358
1.18k
          case 0x5d:
7359
1.21k
          case 0x5e:
7360
1.31k
          case 0x5f:
7361
1.31k
              {
7362
                /** 0111 1111 0101 rsrc   bsr.l %0 */
7363
1.31k
#line 828 "rx-decode.opc"
7364
1.31k
                int rsrc AU = op[1] & 0x0f;
7365
1.31k
                if (trace)
7366
0
                  {
7367
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7368
0
                           "/** 0111 1111 0101 rsrc   bsr.l %0 */",
7369
0
                           op[0], op[1]);
7370
0
                    printf ("  rsrc = 0x%x\n", rsrc);
7371
0
                  }
7372
1.31k
                SYNTAX("bsr.l %0");
7373
1.31k
#line 828 "rx-decode.opc"
7374
1.31k
                ID(jsrrel); DR(rsrc);
7375
7376
1.31k
              }
7377
1.31k
            break;
7378
1.01k
          case 0x80:
7379
1.15k
          case 0x81:
7380
1.17k
          case 0x82:
7381
1.17k
              {
7382
                /** 0111 1111 1000 00sz   suntil%s */
7383
1.17k
#line 852 "rx-decode.opc"
7384
1.17k
                int sz AU = op[1] & 0x03;
7385
1.17k
                if (trace)
7386
0
                  {
7387
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7388
0
                           "/** 0111 1111 1000 00sz   suntil%s */",
7389
0
                           op[0], op[1]);
7390
0
                    printf ("  sz = 0x%x\n", sz);
7391
0
                  }
7392
1.17k
                SYNTAX("suntil%s");
7393
1.17k
#line 852 "rx-decode.opc"
7394
1.17k
                ID(suntil); BWL(sz); F___ZC;
7395
7396
1.17k
              }
7397
1.17k
            break;
7398
433
          case 0x83:
7399
433
              {
7400
                /** 0111 1111 1000 0011   scmpu */
7401
433
                if (trace)
7402
0
                  {
7403
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7404
0
                           "/** 0111 1111 1000 0011   scmpu */",
7405
0
                           op[0], op[1]);
7406
0
                  }
7407
433
                SYNTAX("scmpu");
7408
433
#line 843 "rx-decode.opc"
7409
433
                ID(scmpu); F___ZC;
7410
7411
433
              }
7412
433
            break;
7413
6.30k
          case 0x84:
7414
6.40k
          case 0x85:
7415
6.55k
          case 0x86:
7416
6.55k
              {
7417
                /** 0111 1111 1000 01sz   swhile%s */
7418
6.55k
#line 855 "rx-decode.opc"
7419
6.55k
                int sz AU = op[1] & 0x03;
7420
6.55k
                if (trace)
7421
0
                  {
7422
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7423
0
                           "/** 0111 1111 1000 01sz   swhile%s */",
7424
0
                           op[0], op[1]);
7425
0
                    printf ("  sz = 0x%x\n", sz);
7426
0
                  }
7427
6.55k
                SYNTAX("swhile%s");
7428
6.55k
#line 855 "rx-decode.opc"
7429
6.55k
                ID(swhile); BWL(sz); F___ZC;
7430
7431
6.55k
              }
7432
6.55k
            break;
7433
68
          case 0x87:
7434
68
              {
7435
                /** 0111 1111 1000 0111   smovu */
7436
68
                if (trace)
7437
0
                  {
7438
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7439
0
                           "/** 0111 1111 1000 0111   smovu */",
7440
0
                           op[0], op[1]);
7441
0
                  }
7442
68
                SYNTAX("smovu");
7443
68
#line 846 "rx-decode.opc"
7444
68
                ID(smovu);
7445
7446
68
              }
7447
68
            break;
7448
200
          case 0x88:
7449
859
          case 0x89:
7450
1.51k
          case 0x8a:
7451
1.51k
              {
7452
                /** 0111 1111 1000 10sz   sstr%s */
7453
1.51k
#line 861 "rx-decode.opc"
7454
1.51k
                int sz AU = op[1] & 0x03;
7455
1.51k
                if (trace)
7456
0
                  {
7457
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7458
0
                           "/** 0111 1111 1000 10sz   sstr%s */",
7459
0
                           op[0], op[1]);
7460
0
                    printf ("  sz = 0x%x\n", sz);
7461
0
                  }
7462
1.51k
                SYNTAX("sstr%s");
7463
1.51k
#line 861 "rx-decode.opc"
7464
1.51k
                ID(sstr); BWL(sz);
7465
7466
              /*----------------------------------------------------------------------*/
7467
              /* RMPA                 */
7468
7469
1.51k
              }
7470
1.51k
            break;
7471
37
          case 0x8b:
7472
37
              {
7473
                /** 0111 1111 1000 1011   smovb */
7474
37
                if (trace)
7475
0
                  {
7476
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7477
0
                           "/** 0111 1111 1000 1011   smovb */",
7478
0
                           op[0], op[1]);
7479
0
                  }
7480
37
                SYNTAX("smovb");
7481
37
#line 849 "rx-decode.opc"
7482
37
                ID(smovb);
7483
7484
37
              }
7485
37
            break;
7486
35
          case 0x8c:
7487
78
          case 0x8d:
7488
133
          case 0x8e:
7489
133
              {
7490
                /** 0111 1111 1000 11sz   rmpa%s */
7491
133
#line 867 "rx-decode.opc"
7492
133
                int sz AU = op[1] & 0x03;
7493
133
                if (trace)
7494
0
                  {
7495
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7496
0
                           "/** 0111 1111 1000 11sz   rmpa%s */",
7497
0
                           op[0], op[1]);
7498
0
                    printf ("  sz = 0x%x\n", sz);
7499
0
                  }
7500
133
                SYNTAX("rmpa%s");
7501
133
#line 867 "rx-decode.opc"
7502
133
                ID(rmpa); BWL(sz); F_OS__;
7503
7504
              /*----------------------------------------------------------------------*/
7505
              /* HI/LO stuff                */
7506
7507
133
              }
7508
133
            break;
7509
116
          case 0x8f:
7510
116
              {
7511
                /** 0111 1111 1000 1111   smovf */
7512
116
                if (trace)
7513
0
                  {
7514
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7515
0
                           "/** 0111 1111 1000 1111   smovf */",
7516
0
                           op[0], op[1]);
7517
0
                  }
7518
116
                SYNTAX("smovf");
7519
116
#line 858 "rx-decode.opc"
7520
116
                ID(smovf);
7521
7522
116
              }
7523
116
            break;
7524
33
          case 0x93:
7525
33
              {
7526
                /** 0111 1111 1001 0011   satr */
7527
33
                if (trace)
7528
0
                  {
7529
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7530
0
                           "/** 0111 1111 1001 0011   satr */",
7531
0
                           op[0], op[1]);
7532
0
                  }
7533
33
                SYNTAX("satr");
7534
33
#line 909 "rx-decode.opc"
7535
33
                ID(satr);
7536
7537
              /*----------------------------------------------------------------------*/
7538
              /* FLOAT                */
7539
7540
33
              }
7541
33
            break;
7542
91
          case 0x94:
7543
91
              {
7544
                /** 0111 1111 1001 0100   rtfi */
7545
91
                if (trace)
7546
0
                  {
7547
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7548
0
                           "/** 0111 1111 1001 0100   rtfi */",
7549
0
                           op[0], op[1]);
7550
0
                  }
7551
91
                SYNTAX("rtfi");
7552
91
#line 1044 "rx-decode.opc"
7553
91
                ID(rtfi);
7554
7555
91
              }
7556
91
            break;
7557
161
          case 0x95:
7558
161
              {
7559
                /** 0111 1111 1001 0101   rte */
7560
161
                if (trace)
7561
0
                  {
7562
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7563
0
                           "/** 0111 1111 1001 0101   rte */",
7564
0
                           op[0], op[1]);
7565
0
                  }
7566
161
                SYNTAX("rte");
7567
161
#line 1047 "rx-decode.opc"
7568
161
                ID(rte);
7569
7570
161
              }
7571
161
            break;
7572
7
          case 0x96:
7573
7
              {
7574
                /** 0111 1111 1001 0110   wait */
7575
7
                if (trace)
7576
0
                  {
7577
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7578
0
                           "/** 0111 1111 1001 0110   wait */",
7579
0
                           op[0], op[1]);
7580
0
                  }
7581
7
                SYNTAX("wait");
7582
7
#line 1059 "rx-decode.opc"
7583
7
                ID(wait);
7584
7585
              /*----------------------------------------------------------------------*/
7586
              /* SCcnd                */
7587
7588
7
              }
7589
7
            break;
7590
24
          case 0xa0:
7591
50
          case 0xa1:
7592
95
          case 0xa2:
7593
275
          case 0xa3:
7594
332
          case 0xa4:
7595
612
          case 0xa5:
7596
666
          case 0xa6:
7597
763
          case 0xa7:
7598
794
          case 0xa8:
7599
940
          case 0xa9:
7600
1.01k
          case 0xaa:
7601
1.04k
          case 0xab:
7602
1.19k
          case 0xac:
7603
1.45k
          case 0xad:
7604
1.71k
          case 0xae:
7605
2.03k
          case 0xaf:
7606
2.03k
              {
7607
                /** 0111 1111 1010 rdst     setpsw  %0 */
7608
2.03k
#line 1020 "rx-decode.opc"
7609
2.03k
                int rdst AU = op[1] & 0x0f;
7610
2.03k
                if (trace)
7611
0
                  {
7612
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7613
0
                           "/** 0111 1111 1010 rdst     setpsw  %0 */",
7614
0
                           op[0], op[1]);
7615
0
                    printf ("  rdst = 0x%x\n", rdst);
7616
0
                  }
7617
2.03k
                SYNTAX("setpsw  %0");
7618
2.03k
#line 1020 "rx-decode.opc"
7619
2.03k
                ID(setpsw); DF(rdst);
7620
7621
2.03k
              }
7622
2.03k
            break;
7623
11
          case 0xb0:
7624
32
          case 0xb1:
7625
434
          case 0xb2:
7626
547
          case 0xb3:
7627
736
          case 0xb4:
7628
801
          case 0xb5:
7629
808
          case 0xb6:
7630
840
          case 0xb7:
7631
1.10k
          case 0xb8:
7632
1.25k
          case 0xb9:
7633
1.36k
          case 0xba:
7634
1.50k
          case 0xbb:
7635
1.77k
          case 0xbc:
7636
1.83k
          case 0xbd:
7637
1.84k
          case 0xbe:
7638
1.90k
          case 0xbf:
7639
1.90k
              {
7640
                /** 0111 1111 1011 rdst     clrpsw  %0 */
7641
1.90k
#line 1017 "rx-decode.opc"
7642
1.90k
                int rdst AU = op[1] & 0x0f;
7643
1.90k
                if (trace)
7644
0
                  {
7645
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7646
0
                           "/** 0111 1111 1011 rdst     clrpsw  %0 */",
7647
0
                           op[0], op[1]);
7648
0
                    printf ("  rdst = 0x%x\n", rdst);
7649
0
                  }
7650
1.90k
                SYNTAX("clrpsw  %0");
7651
1.90k
#line 1017 "rx-decode.opc"
7652
1.90k
                ID(clrpsw); DF(rdst);
7653
7654
1.90k
              }
7655
1.90k
            break;
7656
27.8k
          default: UNSUPPORTED(); break;
7657
74.6k
        }
7658
74.6k
      break;
7659
90.2k
    case 0x80:
7660
90.2k
        GETBYTE ();
7661
90.2k
        switch (op[1] & 0x00)
7662
90.2k
        {
7663
90.1k
          case 0x00:
7664
693k
            op_semantics_52:
7665
693k
              {
7666
                /** 10sz 0dsp a dst b src mov%s %1, %0 */
7667
693k
#line 357 "rx-decode.opc"
7668
693k
                int sz AU = (op[0] >> 4) & 0x03;
7669
693k
#line 357 "rx-decode.opc"
7670
693k
                int dsp AU = op[0] & 0x07;
7671
693k
#line 357 "rx-decode.opc"
7672
693k
                int a AU = (op[1] >> 7) & 0x01;
7673
693k
#line 357 "rx-decode.opc"
7674
693k
                int dst AU = (op[1] >> 4) & 0x07;
7675
693k
#line 357 "rx-decode.opc"
7676
693k
                int b AU = (op[1] >> 3) & 0x01;
7677
693k
#line 357 "rx-decode.opc"
7678
693k
                int src AU = op[1] & 0x07;
7679
693k
                if (trace)
7680
0
                  {
7681
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7682
0
                           "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
7683
0
                           op[0], op[1]);
7684
0
                    printf ("  sz = 0x%x,", sz);
7685
0
                    printf ("  dsp = 0x%x,", dsp);
7686
0
                    printf ("  a = 0x%x,", a);
7687
0
                    printf ("  dst = 0x%x,", dst);
7688
0
                    printf ("  b = 0x%x,", b);
7689
0
                    printf ("  src = 0x%x\n", src);
7690
0
                  }
7691
693k
                SYNTAX("mov%s %1, %0");
7692
693k
#line 357 "rx-decode.opc"
7693
693k
                ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
7694
7695
693k
              }
7696
693k
            break;
7697
90.2k
        }
7698
693k
      break;
7699
693k
    case 0x81:
7700
28.1k
        GETBYTE ();
7701
28.1k
        switch (op[1] & 0x00)
7702
28.1k
        {
7703
28.1k
          case 0x00:
7704
28.1k
            goto op_semantics_52;
7705
0
            break;
7706
28.1k
        }
7707
0
      break;
7708
27.0k
    case 0x82:
7709
27.0k
        GETBYTE ();
7710
27.0k
        switch (op[1] & 0x00)
7711
27.0k
        {
7712
27.0k
          case 0x00:
7713
27.0k
            goto op_semantics_52;
7714
0
            break;
7715
27.0k
        }
7716
0
      break;
7717
25.0k
    case 0x83:
7718
25.0k
        GETBYTE ();
7719
25.0k
        switch (op[1] & 0x00)
7720
25.0k
        {
7721
25.0k
          case 0x00:
7722
25.0k
            goto op_semantics_52;
7723
0
            break;
7724
25.0k
        }
7725
0
      break;
7726
27.6k
    case 0x84:
7727
27.6k
        GETBYTE ();
7728
27.6k
        switch (op[1] & 0x00)
7729
27.6k
        {
7730
27.6k
          case 0x00:
7731
27.6k
            goto op_semantics_52;
7732
0
            break;
7733
27.6k
        }
7734
0
      break;
7735
31.6k
    case 0x85:
7736
31.6k
        GETBYTE ();
7737
31.6k
        switch (op[1] & 0x00)
7738
31.6k
        {
7739
31.6k
          case 0x00:
7740
31.6k
            goto op_semantics_52;
7741
0
            break;
7742
31.6k
        }
7743
0
      break;
7744
17.3k
    case 0x86:
7745
17.3k
        GETBYTE ();
7746
17.3k
        switch (op[1] & 0x00)
7747
17.3k
        {
7748
17.3k
          case 0x00:
7749
17.3k
            goto op_semantics_52;
7750
0
            break;
7751
17.3k
        }
7752
0
      break;
7753
23.6k
    case 0x87:
7754
23.6k
        GETBYTE ();
7755
23.6k
        switch (op[1] & 0x00)
7756
23.6k
        {
7757
23.6k
          case 0x00:
7758
23.6k
            goto op_semantics_52;
7759
0
            break;
7760
23.6k
        }
7761
0
      break;
7762
31.8k
    case 0x88:
7763
31.8k
        GETBYTE ();
7764
31.8k
        switch (op[1] & 0x00)
7765
31.8k
        {
7766
31.8k
          case 0x00:
7767
599k
            op_semantics_53:
7768
599k
              {
7769
                /** 10sz 1dsp a src b dst mov%s %1, %0 */
7770
599k
#line 354 "rx-decode.opc"
7771
599k
                int sz AU = (op[0] >> 4) & 0x03;
7772
599k
#line 354 "rx-decode.opc"
7773
599k
                int dsp AU = op[0] & 0x07;
7774
599k
#line 354 "rx-decode.opc"
7775
599k
                int a AU = (op[1] >> 7) & 0x01;
7776
599k
#line 354 "rx-decode.opc"
7777
599k
                int src AU = (op[1] >> 4) & 0x07;
7778
599k
#line 354 "rx-decode.opc"
7779
599k
                int b AU = (op[1] >> 3) & 0x01;
7780
599k
#line 354 "rx-decode.opc"
7781
599k
                int dst AU = op[1] & 0x07;
7782
599k
                if (trace)
7783
0
                  {
7784
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
7785
0
                           "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
7786
0
                           op[0], op[1]);
7787
0
                    printf ("  sz = 0x%x,", sz);
7788
0
                    printf ("  dsp = 0x%x,", dsp);
7789
0
                    printf ("  a = 0x%x,", a);
7790
0
                    printf ("  src = 0x%x,", src);
7791
0
                    printf ("  b = 0x%x,", b);
7792
0
                    printf ("  dst = 0x%x\n", dst);
7793
0
                  }
7794
599k
                SYNTAX("mov%s %1, %0");
7795
599k
#line 354 "rx-decode.opc"
7796
599k
                ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
7797
7798
599k
              }
7799
599k
            break;
7800
31.8k
        }
7801
599k
      break;
7802
599k
    case 0x89:
7803
38.5k
        GETBYTE ();
7804
38.5k
        switch (op[1] & 0x00)
7805
38.5k
        {
7806
38.5k
          case 0x00:
7807
38.5k
            goto op_semantics_53;
7808
0
            break;
7809
38.5k
        }
7810
0
      break;
7811
25.9k
    case 0x8a:
7812
25.9k
        GETBYTE ();
7813
25.9k
        switch (op[1] & 0x00)
7814
25.9k
        {
7815
25.9k
          case 0x00:
7816
25.9k
            goto op_semantics_53;
7817
0
            break;
7818
25.9k
        }
7819
0
      break;
7820
37.4k
    case 0x8b:
7821
37.4k
        GETBYTE ();
7822
37.4k
        switch (op[1] & 0x00)
7823
37.4k
        {
7824
37.4k
          case 0x00:
7825
37.4k
            goto op_semantics_53;
7826
0
            break;
7827
37.4k
        }
7828
0
      break;
7829
24.2k
    case 0x8c:
7830
24.2k
        GETBYTE ();
7831
24.2k
        switch (op[1] & 0x00)
7832
24.2k
        {
7833
24.2k
          case 0x00:
7834
24.2k
            goto op_semantics_53;
7835
0
            break;
7836
24.2k
        }
7837
0
      break;
7838
31.5k
    case 0x8d:
7839
31.5k
        GETBYTE ();
7840
31.5k
        switch (op[1] & 0x00)
7841
31.5k
        {
7842
31.5k
          case 0x00:
7843
31.5k
            goto op_semantics_53;
7844
0
            break;
7845
31.5k
        }
7846
0
      break;
7847
21.5k
    case 0x8e:
7848
21.5k
        GETBYTE ();
7849
21.5k
        switch (op[1] & 0x00)
7850
21.5k
        {
7851
21.5k
          case 0x00:
7852
21.5k
            goto op_semantics_53;
7853
0
            break;
7854
21.5k
        }
7855
0
      break;
7856
22.9k
    case 0x8f:
7857
22.9k
        GETBYTE ();
7858
22.9k
        switch (op[1] & 0x00)
7859
22.9k
        {
7860
22.9k
          case 0x00:
7861
22.9k
            goto op_semantics_53;
7862
0
            break;
7863
22.9k
        }
7864
0
      break;
7865
47.9k
    case 0x90:
7866
47.9k
        GETBYTE ();
7867
47.9k
        switch (op[1] & 0x00)
7868
47.9k
        {
7869
47.9k
          case 0x00:
7870
47.9k
            goto op_semantics_52;
7871
0
            break;
7872
47.9k
        }
7873
0
      break;
7874
28.0k
    case 0x91:
7875
28.0k
        GETBYTE ();
7876
28.0k
        switch (op[1] & 0x00)
7877
28.0k
        {
7878
28.0k
          case 0x00:
7879
28.0k
            goto op_semantics_52;
7880
0
            break;
7881
28.0k
        }
7882
0
      break;
7883
34.6k
    case 0x92:
7884
34.6k
        GETBYTE ();
7885
34.6k
        switch (op[1] & 0x00)
7886
34.6k
        {
7887
34.6k
          case 0x00:
7888
34.6k
            goto op_semantics_52;
7889
0
            break;
7890
34.6k
        }
7891
0
      break;
7892
25.8k
    case 0x93:
7893
25.8k
        GETBYTE ();
7894
25.8k
        switch (op[1] & 0x00)
7895
25.8k
        {
7896
25.8k
          case 0x00:
7897
25.8k
            goto op_semantics_52;
7898
0
            break;
7899
25.8k
        }
7900
0
      break;
7901
25.3k
    case 0x94:
7902
25.3k
        GETBYTE ();
7903
25.3k
        switch (op[1] & 0x00)
7904
25.3k
        {
7905
25.3k
          case 0x00:
7906
25.3k
            goto op_semantics_52;
7907
0
            break;
7908
25.3k
        }
7909
0
      break;
7910
16.2k
    case 0x95:
7911
16.2k
        GETBYTE ();
7912
16.2k
        switch (op[1] & 0x00)
7913
16.2k
        {
7914
16.2k
          case 0x00:
7915
16.2k
            goto op_semantics_52;
7916
0
            break;
7917
16.2k
        }
7918
0
      break;
7919
15.2k
    case 0x96:
7920
15.2k
        GETBYTE ();
7921
15.2k
        switch (op[1] & 0x00)
7922
15.2k
        {
7923
15.2k
          case 0x00:
7924
15.2k
            goto op_semantics_52;
7925
0
            break;
7926
15.2k
        }
7927
0
      break;
7928
24.8k
    case 0x97:
7929
24.8k
        GETBYTE ();
7930
24.8k
        switch (op[1] & 0x00)
7931
24.8k
        {
7932
24.8k
          case 0x00:
7933
24.8k
            goto op_semantics_52;
7934
0
            break;
7935
24.8k
        }
7936
0
      break;
7937
24.2k
    case 0x98:
7938
24.2k
        GETBYTE ();
7939
24.2k
        switch (op[1] & 0x00)
7940
24.2k
        {
7941
24.2k
          case 0x00:
7942
24.2k
            goto op_semantics_53;
7943
0
            break;
7944
24.2k
        }
7945
0
      break;
7946
23.1k
    case 0x99:
7947
23.1k
        GETBYTE ();
7948
23.1k
        switch (op[1] & 0x00)
7949
23.1k
        {
7950
23.1k
          case 0x00:
7951
23.1k
            goto op_semantics_53;
7952
0
            break;
7953
23.1k
        }
7954
0
      break;
7955
18.6k
    case 0x9a:
7956
18.6k
        GETBYTE ();
7957
18.6k
        switch (op[1] & 0x00)
7958
18.6k
        {
7959
18.6k
          case 0x00:
7960
18.6k
            goto op_semantics_53;
7961
0
            break;
7962
18.6k
        }
7963
0
      break;
7964
33.8k
    case 0x9b:
7965
33.8k
        GETBYTE ();
7966
33.8k
        switch (op[1] & 0x00)
7967
33.8k
        {
7968
33.8k
          case 0x00:
7969
33.8k
            goto op_semantics_53;
7970
0
            break;
7971
33.8k
        }
7972
0
      break;
7973
20.9k
    case 0x9c:
7974
20.9k
        GETBYTE ();
7975
20.9k
        switch (op[1] & 0x00)
7976
20.9k
        {
7977
20.9k
          case 0x00:
7978
20.9k
            goto op_semantics_53;
7979
0
            break;
7980
20.9k
        }
7981
0
      break;
7982
22.7k
    case 0x9d:
7983
22.7k
        GETBYTE ();
7984
22.7k
        switch (op[1] & 0x00)
7985
22.7k
        {
7986
22.7k
          case 0x00:
7987
22.7k
            goto op_semantics_53;
7988
0
            break;
7989
22.7k
        }
7990
0
      break;
7991
17.1k
    case 0x9e:
7992
17.1k
        GETBYTE ();
7993
17.1k
        switch (op[1] & 0x00)
7994
17.1k
        {
7995
17.1k
          case 0x00:
7996
17.1k
            goto op_semantics_53;
7997
0
            break;
7998
17.1k
        }
7999
0
      break;
8000
23.9k
    case 0x9f:
8001
23.9k
        GETBYTE ();
8002
23.9k
        switch (op[1] & 0x00)
8003
23.9k
        {
8004
23.9k
          case 0x00:
8005
23.9k
            goto op_semantics_53;
8006
0
            break;
8007
23.9k
        }
8008
0
      break;
8009
37.0k
    case 0xa0:
8010
37.0k
        GETBYTE ();
8011
37.0k
        switch (op[1] & 0x00)
8012
37.0k
        {
8013
37.0k
          case 0x00:
8014
37.0k
            goto op_semantics_52;
8015
0
            break;
8016
37.0k
        }
8017
0
      break;
8018
24.7k
    case 0xa1:
8019
24.7k
        GETBYTE ();
8020
24.7k
        switch (op[1] & 0x00)
8021
24.7k
        {
8022
24.7k
          case 0x00:
8023
24.7k
            goto op_semantics_52;
8024
0
            break;
8025
24.7k
        }
8026
0
      break;
8027
29.5k
    case 0xa2:
8028
29.5k
        GETBYTE ();
8029
29.5k
        switch (op[1] & 0x00)
8030
29.5k
        {
8031
29.5k
          case 0x00:
8032
29.5k
            goto op_semantics_52;
8033
0
            break;
8034
29.5k
        }
8035
0
      break;
8036
20.6k
    case 0xa3:
8037
20.6k
        GETBYTE ();
8038
20.6k
        switch (op[1] & 0x00)
8039
20.6k
        {
8040
20.6k
          case 0x00:
8041
20.6k
            goto op_semantics_52;
8042
0
            break;
8043
20.6k
        }
8044
0
      break;
8045
26.5k
    case 0xa4:
8046
26.5k
        GETBYTE ();
8047
26.5k
        switch (op[1] & 0x00)
8048
26.5k
        {
8049
26.5k
          case 0x00:
8050
26.5k
            goto op_semantics_52;
8051
0
            break;
8052
26.5k
        }
8053
0
      break;
8054
23.0k
    case 0xa5:
8055
23.0k
        GETBYTE ();
8056
23.0k
        switch (op[1] & 0x00)
8057
23.0k
        {
8058
23.0k
          case 0x00:
8059
23.0k
            goto op_semantics_52;
8060
0
            break;
8061
23.0k
        }
8062
0
      break;
8063
17.6k
    case 0xa6:
8064
17.6k
        GETBYTE ();
8065
17.6k
        switch (op[1] & 0x00)
8066
17.6k
        {
8067
17.6k
          case 0x00:
8068
17.6k
            goto op_semantics_52;
8069
0
            break;
8070
17.6k
        }
8071
0
      break;
8072
25.5k
    case 0xa7:
8073
25.5k
        GETBYTE ();
8074
25.5k
        switch (op[1] & 0x00)
8075
25.5k
        {
8076
25.5k
          case 0x00:
8077
25.5k
            goto op_semantics_52;
8078
0
            break;
8079
25.5k
        }
8080
0
      break;
8081
21.5k
    case 0xa8:
8082
21.5k
        GETBYTE ();
8083
21.5k
        switch (op[1] & 0x00)
8084
21.5k
        {
8085
21.5k
          case 0x00:
8086
21.5k
            goto op_semantics_53;
8087
0
            break;
8088
21.5k
        }
8089
0
      break;
8090
30.4k
    case 0xa9:
8091
30.4k
        GETBYTE ();
8092
30.4k
        switch (op[1] & 0x00)
8093
30.4k
        {
8094
30.4k
          case 0x00:
8095
30.4k
            goto op_semantics_53;
8096
0
            break;
8097
30.4k
        }
8098
0
      break;
8099
24.5k
    case 0xaa:
8100
24.5k
        GETBYTE ();
8101
24.5k
        switch (op[1] & 0x00)
8102
24.5k
        {
8103
24.5k
          case 0x00:
8104
24.5k
            goto op_semantics_53;
8105
0
            break;
8106
24.5k
        }
8107
0
      break;
8108
19.7k
    case 0xab:
8109
19.7k
        GETBYTE ();
8110
19.7k
        switch (op[1] & 0x00)
8111
19.7k
        {
8112
19.7k
          case 0x00:
8113
19.7k
            goto op_semantics_53;
8114
0
            break;
8115
19.7k
        }
8116
0
      break;
8117
23.6k
    case 0xac:
8118
23.6k
        GETBYTE ();
8119
23.6k
        switch (op[1] & 0x00)
8120
23.6k
        {
8121
23.6k
          case 0x00:
8122
23.6k
            goto op_semantics_53;
8123
0
            break;
8124
23.6k
        }
8125
0
      break;
8126
20.4k
    case 0xad:
8127
20.4k
        GETBYTE ();
8128
20.4k
        switch (op[1] & 0x00)
8129
20.4k
        {
8130
20.4k
          case 0x00:
8131
20.4k
            goto op_semantics_53;
8132
0
            break;
8133
20.4k
        }
8134
0
      break;
8135
20.5k
    case 0xae:
8136
20.5k
        GETBYTE ();
8137
20.5k
        switch (op[1] & 0x00)
8138
20.5k
        {
8139
20.5k
          case 0x00:
8140
20.5k
            goto op_semantics_53;
8141
0
            break;
8142
20.5k
        }
8143
0
      break;
8144
20.1k
    case 0xaf:
8145
20.1k
        GETBYTE ();
8146
20.1k
        switch (op[1] & 0x00)
8147
20.1k
        {
8148
20.1k
          case 0x00:
8149
20.1k
            goto op_semantics_53;
8150
0
            break;
8151
20.1k
        }
8152
0
      break;
8153
28.2k
    case 0xb0:
8154
28.2k
        GETBYTE ();
8155
28.2k
        switch (op[1] & 0x00)
8156
28.2k
        {
8157
28.2k
          case 0x00:
8158
357k
            op_semantics_54:
8159
357k
              {
8160
                /** 1011 w dsp a src b dst  movu%s  %1, %0 */
8161
357k
#line 377 "rx-decode.opc"
8162
357k
                int w AU = (op[0] >> 3) & 0x01;
8163
357k
#line 377 "rx-decode.opc"
8164
357k
                int dsp AU = op[0] & 0x07;
8165
357k
#line 377 "rx-decode.opc"
8166
357k
                int a AU = (op[1] >> 7) & 0x01;
8167
357k
#line 377 "rx-decode.opc"
8168
357k
                int src AU = (op[1] >> 4) & 0x07;
8169
357k
#line 377 "rx-decode.opc"
8170
357k
                int b AU = (op[1] >> 3) & 0x01;
8171
357k
#line 377 "rx-decode.opc"
8172
357k
                int dst AU = op[1] & 0x07;
8173
357k
                if (trace)
8174
0
                  {
8175
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8176
0
                           "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
8177
0
                           op[0], op[1]);
8178
0
                    printf ("  w = 0x%x,", w);
8179
0
                    printf ("  dsp = 0x%x,", dsp);
8180
0
                    printf ("  a = 0x%x,", a);
8181
0
                    printf ("  src = 0x%x,", src);
8182
0
                    printf ("  b = 0x%x,", b);
8183
0
                    printf ("  dst = 0x%x\n", dst);
8184
0
                  }
8185
357k
                SYNTAX("movu%s  %1, %0");
8186
357k
#line 377 "rx-decode.opc"
8187
357k
                ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
8188
8189
357k
              }
8190
357k
            break;
8191
28.2k
        }
8192
357k
      break;
8193
357k
    case 0xb1:
8194
18.9k
        GETBYTE ();
8195
18.9k
        switch (op[1] & 0x00)
8196
18.9k
        {
8197
18.9k
          case 0x00:
8198
18.9k
            goto op_semantics_54;
8199
0
            break;
8200
18.9k
        }
8201
0
      break;
8202
18.0k
    case 0xb2:
8203
18.0k
        GETBYTE ();
8204
18.0k
        switch (op[1] & 0x00)
8205
18.0k
        {
8206
17.9k
          case 0x00:
8207
17.9k
            goto op_semantics_54;
8208
0
            break;
8209
18.0k
        }
8210
0
      break;
8211
18.7k
    case 0xb3:
8212
18.7k
        GETBYTE ();
8213
18.7k
        switch (op[1] & 0x00)
8214
18.7k
        {
8215
18.7k
          case 0x00:
8216
18.7k
            goto op_semantics_54;
8217
0
            break;
8218
18.7k
        }
8219
0
      break;
8220
16.2k
    case 0xb4:
8221
16.2k
        GETBYTE ();
8222
16.2k
        switch (op[1] & 0x00)
8223
16.2k
        {
8224
16.1k
          case 0x00:
8225
16.1k
            goto op_semantics_54;
8226
0
            break;
8227
16.2k
        }
8228
0
      break;
8229
24.2k
    case 0xb5:
8230
24.2k
        GETBYTE ();
8231
24.2k
        switch (op[1] & 0x00)
8232
24.2k
        {
8233
24.2k
          case 0x00:
8234
24.2k
            goto op_semantics_54;
8235
0
            break;
8236
24.2k
        }
8237
0
      break;
8238
21.4k
    case 0xb6:
8239
21.4k
        GETBYTE ();
8240
21.4k
        switch (op[1] & 0x00)
8241
21.4k
        {
8242
21.3k
          case 0x00:
8243
21.3k
            goto op_semantics_54;
8244
0
            break;
8245
21.4k
        }
8246
0
      break;
8247
20.7k
    case 0xb7:
8248
20.7k
        GETBYTE ();
8249
20.7k
        switch (op[1] & 0x00)
8250
20.7k
        {
8251
20.7k
          case 0x00:
8252
20.7k
            goto op_semantics_54;
8253
0
            break;
8254
20.7k
        }
8255
0
      break;
8256
26.2k
    case 0xb8:
8257
26.2k
        GETBYTE ();
8258
26.2k
        switch (op[1] & 0x00)
8259
26.2k
        {
8260
26.2k
          case 0x00:
8261
26.2k
            goto op_semantics_54;
8262
0
            break;
8263
26.2k
        }
8264
0
      break;
8265
23.6k
    case 0xb9:
8266
23.6k
        GETBYTE ();
8267
23.6k
        switch (op[1] & 0x00)
8268
23.6k
        {
8269
23.6k
          case 0x00:
8270
23.6k
            goto op_semantics_54;
8271
0
            break;
8272
23.6k
        }
8273
0
      break;
8274
26.5k
    case 0xba:
8275
26.5k
        GETBYTE ();
8276
26.5k
        switch (op[1] & 0x00)
8277
26.5k
        {
8278
26.5k
          case 0x00:
8279
26.5k
            goto op_semantics_54;
8280
0
            break;
8281
26.5k
        }
8282
0
      break;
8283
21.7k
    case 0xbb:
8284
21.7k
        GETBYTE ();
8285
21.7k
        switch (op[1] & 0x00)
8286
21.7k
        {
8287
21.7k
          case 0x00:
8288
21.7k
            goto op_semantics_54;
8289
0
            break;
8290
21.7k
        }
8291
0
      break;
8292
24.8k
    case 0xbc:
8293
24.8k
        GETBYTE ();
8294
24.8k
        switch (op[1] & 0x00)
8295
24.8k
        {
8296
24.8k
          case 0x00:
8297
24.8k
            goto op_semantics_54;
8298
0
            break;
8299
24.8k
        }
8300
0
      break;
8301
17.0k
    case 0xbd:
8302
17.0k
        GETBYTE ();
8303
17.0k
        switch (op[1] & 0x00)
8304
17.0k
        {
8305
17.0k
          case 0x00:
8306
17.0k
            goto op_semantics_54;
8307
0
            break;
8308
17.0k
        }
8309
0
      break;
8310
23.8k
    case 0xbe:
8311
23.8k
        GETBYTE ();
8312
23.8k
        switch (op[1] & 0x00)
8313
23.8k
        {
8314
23.8k
          case 0x00:
8315
23.8k
            goto op_semantics_54;
8316
0
            break;
8317
23.8k
        }
8318
0
      break;
8319
27.0k
    case 0xbf:
8320
27.0k
        GETBYTE ();
8321
27.0k
        switch (op[1] & 0x00)
8322
27.0k
        {
8323
27.0k
          case 0x00:
8324
27.0k
            goto op_semantics_54;
8325
0
            break;
8326
27.0k
        }
8327
0
      break;
8328
38.1k
    case 0xc0:
8329
38.1k
        GETBYTE ();
8330
38.1k
        switch (op[1] & 0x00)
8331
38.1k
        {
8332
38.0k
          case 0x00:
8333
1.13M
            op_semantics_55:
8334
1.13M
              {
8335
                /** 11sz sd ss rsrc rdst  mov%s %1, %0 */
8336
1.13M
#line 335 "rx-decode.opc"
8337
1.13M
                int sz AU = (op[0] >> 4) & 0x03;
8338
1.13M
#line 335 "rx-decode.opc"
8339
1.13M
                int sd AU = (op[0] >> 2) & 0x03;
8340
1.13M
#line 335 "rx-decode.opc"
8341
1.13M
                int ss AU = op[0] & 0x03;
8342
1.13M
#line 335 "rx-decode.opc"
8343
1.13M
                int rsrc AU = (op[1] >> 4) & 0x0f;
8344
1.13M
#line 335 "rx-decode.opc"
8345
1.13M
                int rdst AU = op[1] & 0x0f;
8346
1.13M
                if (trace)
8347
0
                  {
8348
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8349
0
                           "/** 11sz sd ss rsrc rdst  mov%s %1, %0 */",
8350
0
                           op[0], op[1]);
8351
0
                    printf ("  sz = 0x%x,", sz);
8352
0
                    printf ("  sd = 0x%x,", sd);
8353
0
                    printf ("  ss = 0x%x,", ss);
8354
0
                    printf ("  rsrc = 0x%x,", rsrc);
8355
0
                    printf ("  rdst = 0x%x\n", rdst);
8356
0
                  }
8357
1.13M
                SYNTAX("mov%s %1, %0");
8358
1.13M
#line 335 "rx-decode.opc"
8359
1.13M
                if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360
3.15k
                  {
8361
3.15k
                    ID(nop2);
8362
3.15k
                    SYNTAX ("nop\t; mov.l\tr0, r0");
8363
3.15k
                  }
8364
1.12M
                else
8365
1.12M
                  {
8366
1.12M
                    ID(mov); sBWL(sz); F_____;
8367
1.12M
                    if ((ss == 3) && (sd != 3))
8368
192k
                {
8369
192k
                  SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370
192k
                }
8371
936k
                    else
8372
936k
                {
8373
936k
                  SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374
936k
                }
8375
1.12M
                  }
8376
8377
1.13M
              }
8378
1.13M
            break;
8379
38.1k
        }
8380
1.13M
      break;
8381
1.13M
    case 0xc1:
8382
23.8k
        GETBYTE ();
8383
23.8k
        switch (op[1] & 0x00)
8384
23.8k
        {
8385
23.8k
          case 0x00:
8386
23.8k
            goto op_semantics_55;
8387
0
            break;
8388
23.8k
        }
8389
0
      break;
8390
18.9k
    case 0xc2:
8391
18.9k
        GETBYTE ();
8392
18.9k
        switch (op[1] & 0x00)
8393
18.9k
        {
8394
18.9k
          case 0x00:
8395
18.9k
            goto op_semantics_55;
8396
0
            break;
8397
18.9k
        }
8398
0
      break;
8399
20.9k
    case 0xc3:
8400
20.9k
        GETBYTE ();
8401
20.9k
        switch (op[1] & 0x00)
8402
20.9k
        {
8403
20.9k
          case 0x00:
8404
20.9k
            goto op_semantics_55;
8405
0
            break;
8406
20.9k
        }
8407
0
      break;
8408
26.4k
    case 0xc4:
8409
26.4k
        GETBYTE ();
8410
26.4k
        switch (op[1] & 0x00)
8411
26.4k
        {
8412
26.4k
          case 0x00:
8413
26.4k
            goto op_semantics_55;
8414
0
            break;
8415
26.4k
        }
8416
0
      break;
8417
18.2k
    case 0xc5:
8418
18.2k
        GETBYTE ();
8419
18.2k
        switch (op[1] & 0x00)
8420
18.2k
        {
8421
18.2k
          case 0x00:
8422
18.2k
            goto op_semantics_55;
8423
0
            break;
8424
18.2k
        }
8425
0
      break;
8426
17.7k
    case 0xc6:
8427
17.7k
        GETBYTE ();
8428
17.7k
        switch (op[1] & 0x00)
8429
17.7k
        {
8430
17.7k
          case 0x00:
8431
17.7k
            goto op_semantics_55;
8432
0
            break;
8433
17.7k
        }
8434
0
      break;
8435
20.3k
    case 0xc7:
8436
20.3k
        GETBYTE ();
8437
20.3k
        switch (op[1] & 0x00)
8438
20.3k
        {
8439
20.3k
          case 0x00:
8440
20.3k
            goto op_semantics_55;
8441
0
            break;
8442
20.3k
        }
8443
0
      break;
8444
23.3k
    case 0xc8:
8445
23.3k
        GETBYTE ();
8446
23.3k
        switch (op[1] & 0x00)
8447
23.3k
        {
8448
23.3k
          case 0x00:
8449
23.3k
            goto op_semantics_55;
8450
0
            break;
8451
23.3k
        }
8452
0
      break;
8453
22.9k
    case 0xc9:
8454
22.9k
        GETBYTE ();
8455
22.9k
        switch (op[1] & 0x00)
8456
22.9k
        {
8457
22.9k
          case 0x00:
8458
22.9k
            goto op_semantics_55;
8459
0
            break;
8460
22.9k
        }
8461
0
      break;
8462
16.9k
    case 0xca:
8463
16.9k
        GETBYTE ();
8464
16.9k
        switch (op[1] & 0x00)
8465
16.9k
        {
8466
16.9k
          case 0x00:
8467
16.9k
            goto op_semantics_55;
8468
0
            break;
8469
16.9k
        }
8470
0
      break;
8471
22.2k
    case 0xcb:
8472
22.2k
        GETBYTE ();
8473
22.2k
        switch (op[1] & 0x00)
8474
22.2k
        {
8475
22.2k
          case 0x00:
8476
22.2k
            goto op_semantics_55;
8477
0
            break;
8478
22.2k
        }
8479
0
      break;
8480
37.6k
    case 0xcc:
8481
37.6k
        GETBYTE ();
8482
37.6k
        switch (op[1] & 0x00)
8483
37.6k
        {
8484
37.6k
          case 0x00:
8485
37.6k
            goto op_semantics_55;
8486
0
            break;
8487
37.6k
        }
8488
0
      break;
8489
22.6k
    case 0xcd:
8490
22.6k
        GETBYTE ();
8491
22.6k
        switch (op[1] & 0x00)
8492
22.6k
        {
8493
22.6k
          case 0x00:
8494
22.6k
            goto op_semantics_55;
8495
0
            break;
8496
22.6k
        }
8497
0
      break;
8498
22.4k
    case 0xce:
8499
22.4k
        GETBYTE ();
8500
22.4k
        switch (op[1] & 0x00)
8501
22.4k
        {
8502
22.4k
          case 0x00:
8503
22.4k
            goto op_semantics_55;
8504
0
            break;
8505
22.4k
        }
8506
0
      break;
8507
24.7k
    case 0xcf:
8508
24.7k
        GETBYTE ();
8509
24.7k
        switch (op[1] & 0x00)
8510
24.7k
        {
8511
24.7k
          case 0x00:
8512
24.7k
            goto op_semantics_55;
8513
0
            break;
8514
24.7k
        }
8515
0
      break;
8516
23.8k
    case 0xd0:
8517
23.8k
        GETBYTE ();
8518
23.8k
        switch (op[1] & 0x00)
8519
23.8k
        {
8520
23.8k
          case 0x00:
8521
23.8k
            goto op_semantics_55;
8522
0
            break;
8523
23.8k
        }
8524
0
      break;
8525
19.6k
    case 0xd1:
8526
19.6k
        GETBYTE ();
8527
19.6k
        switch (op[1] & 0x00)
8528
19.6k
        {
8529
19.6k
          case 0x00:
8530
19.6k
            goto op_semantics_55;
8531
0
            break;
8532
19.6k
        }
8533
0
      break;
8534
18.6k
    case 0xd2:
8535
18.6k
        GETBYTE ();
8536
18.6k
        switch (op[1] & 0x00)
8537
18.6k
        {
8538
18.6k
          case 0x00:
8539
18.6k
            goto op_semantics_55;
8540
0
            break;
8541
18.6k
        }
8542
0
      break;
8543
18.1k
    case 0xd3:
8544
18.1k
        GETBYTE ();
8545
18.1k
        switch (op[1] & 0x00)
8546
18.1k
        {
8547
18.1k
          case 0x00:
8548
18.1k
            goto op_semantics_55;
8549
0
            break;
8550
18.1k
        }
8551
0
      break;
8552
15.3k
    case 0xd4:
8553
15.3k
        GETBYTE ();
8554
15.3k
        switch (op[1] & 0x00)
8555
15.3k
        {
8556
15.3k
          case 0x00:
8557
15.3k
            goto op_semantics_55;
8558
0
            break;
8559
15.3k
        }
8560
0
      break;
8561
19.5k
    case 0xd5:
8562
19.5k
        GETBYTE ();
8563
19.5k
        switch (op[1] & 0x00)
8564
19.5k
        {
8565
19.5k
          case 0x00:
8566
19.5k
            goto op_semantics_55;
8567
0
            break;
8568
19.5k
        }
8569
0
      break;
8570
13.5k
    case 0xd6:
8571
13.5k
        GETBYTE ();
8572
13.5k
        switch (op[1] & 0x00)
8573
13.5k
        {
8574
13.5k
          case 0x00:
8575
13.5k
            goto op_semantics_55;
8576
0
            break;
8577
13.5k
        }
8578
0
      break;
8579
16.5k
    case 0xd7:
8580
16.5k
        GETBYTE ();
8581
16.5k
        switch (op[1] & 0x00)
8582
16.5k
        {
8583
16.5k
          case 0x00:
8584
16.5k
            goto op_semantics_55;
8585
0
            break;
8586
16.5k
        }
8587
0
      break;
8588
17.9k
    case 0xd8:
8589
17.9k
        GETBYTE ();
8590
17.9k
        switch (op[1] & 0x00)
8591
17.9k
        {
8592
17.9k
          case 0x00:
8593
17.9k
            goto op_semantics_55;
8594
0
            break;
8595
17.9k
        }
8596
0
      break;
8597
11.4k
    case 0xd9:
8598
11.4k
        GETBYTE ();
8599
11.4k
        switch (op[1] & 0x00)
8600
11.4k
        {
8601
11.4k
          case 0x00:
8602
11.4k
            goto op_semantics_55;
8603
0
            break;
8604
11.4k
        }
8605
0
      break;
8606
18.0k
    case 0xda:
8607
18.0k
        GETBYTE ();
8608
18.0k
        switch (op[1] & 0x00)
8609
18.0k
        {
8610
18.0k
          case 0x00:
8611
18.0k
            goto op_semantics_55;
8612
0
            break;
8613
18.0k
        }
8614
0
      break;
8615
21.1k
    case 0xdb:
8616
21.1k
        GETBYTE ();
8617
21.1k
        switch (op[1] & 0x00)
8618
21.1k
        {
8619
21.1k
          case 0x00:
8620
21.1k
            goto op_semantics_55;
8621
0
            break;
8622
21.1k
        }
8623
0
      break;
8624
16.3k
    case 0xdc:
8625
16.3k
        GETBYTE ();
8626
16.3k
        switch (op[1] & 0x00)
8627
16.3k
        {
8628
16.3k
          case 0x00:
8629
16.3k
            goto op_semantics_55;
8630
0
            break;
8631
16.3k
        }
8632
0
      break;
8633
17.3k
    case 0xdd:
8634
17.3k
        GETBYTE ();
8635
17.3k
        switch (op[1] & 0x00)
8636
17.3k
        {
8637
17.3k
          case 0x00:
8638
17.3k
            goto op_semantics_55;
8639
0
            break;
8640
17.3k
        }
8641
0
      break;
8642
17.6k
    case 0xde:
8643
17.6k
        GETBYTE ();
8644
17.6k
        switch (op[1] & 0x00)
8645
17.6k
        {
8646
17.6k
          case 0x00:
8647
17.6k
            goto op_semantics_55;
8648
0
            break;
8649
17.6k
        }
8650
0
      break;
8651
31.3k
    case 0xdf:
8652
31.3k
        GETBYTE ();
8653
31.3k
        switch (op[1] & 0x00)
8654
31.3k
        {
8655
31.3k
          case 0x00:
8656
31.3k
            goto op_semantics_55;
8657
0
            break;
8658
31.3k
        }
8659
0
      break;
8660
34.9k
    case 0xe0:
8661
34.9k
        GETBYTE ();
8662
34.9k
        switch (op[1] & 0x00)
8663
34.9k
        {
8664
34.9k
          case 0x00:
8665
34.9k
            goto op_semantics_55;
8666
0
            break;
8667
34.9k
        }
8668
0
      break;
8669
32.1k
    case 0xe1:
8670
32.1k
        GETBYTE ();
8671
32.1k
        switch (op[1] & 0x00)
8672
32.1k
        {
8673
32.1k
          case 0x00:
8674
32.1k
            goto op_semantics_55;
8675
0
            break;
8676
32.1k
        }
8677
0
      break;
8678
25.2k
    case 0xe2:
8679
25.2k
        GETBYTE ();
8680
25.2k
        switch (op[1] & 0x00)
8681
25.2k
        {
8682
25.2k
          case 0x00:
8683
25.2k
            goto op_semantics_55;
8684
0
            break;
8685
25.2k
        }
8686
0
      break;
8687
22.8k
    case 0xe3:
8688
22.8k
        GETBYTE ();
8689
22.8k
        switch (op[1] & 0x00)
8690
22.8k
        {
8691
22.8k
          case 0x00:
8692
22.8k
            goto op_semantics_55;
8693
0
            break;
8694
22.8k
        }
8695
0
      break;
8696
26.7k
    case 0xe4:
8697
26.7k
        GETBYTE ();
8698
26.7k
        switch (op[1] & 0x00)
8699
26.7k
        {
8700
26.7k
          case 0x00:
8701
26.7k
            goto op_semantics_55;
8702
0
            break;
8703
26.7k
        }
8704
0
      break;
8705
37.0k
    case 0xe5:
8706
37.0k
        GETBYTE ();
8707
37.0k
        switch (op[1] & 0x00)
8708
37.0k
        {
8709
37.0k
          case 0x00:
8710
37.0k
            goto op_semantics_55;
8711
0
            break;
8712
37.0k
        }
8713
0
      break;
8714
24.1k
    case 0xe6:
8715
24.1k
        GETBYTE ();
8716
24.1k
        switch (op[1] & 0x00)
8717
24.1k
        {
8718
24.1k
          case 0x00:
8719
24.1k
            goto op_semantics_55;
8720
0
            break;
8721
24.1k
        }
8722
0
      break;
8723
25.5k
    case 0xe7:
8724
25.5k
        GETBYTE ();
8725
25.5k
        switch (op[1] & 0x00)
8726
25.5k
        {
8727
25.5k
          case 0x00:
8728
25.5k
            goto op_semantics_55;
8729
0
            break;
8730
25.5k
        }
8731
0
      break;
8732
39.4k
    case 0xe8:
8733
39.4k
        GETBYTE ();
8734
39.4k
        switch (op[1] & 0x00)
8735
39.4k
        {
8736
39.4k
          case 0x00:
8737
39.4k
            goto op_semantics_55;
8738
0
            break;
8739
39.4k
        }
8740
0
      break;
8741
23.8k
    case 0xe9:
8742
23.8k
        GETBYTE ();
8743
23.8k
        switch (op[1] & 0x00)
8744
23.8k
        {
8745
23.8k
          case 0x00:
8746
23.8k
            goto op_semantics_55;
8747
0
            break;
8748
23.8k
        }
8749
0
      break;
8750
26.2k
    case 0xea:
8751
26.2k
        GETBYTE ();
8752
26.2k
        switch (op[1] & 0x00)
8753
26.2k
        {
8754
26.2k
          case 0x00:
8755
26.2k
            goto op_semantics_55;
8756
0
            break;
8757
26.2k
        }
8758
0
      break;
8759
24.9k
    case 0xeb:
8760
24.9k
        GETBYTE ();
8761
24.9k
        switch (op[1] & 0x00)
8762
24.9k
        {
8763
24.9k
          case 0x00:
8764
24.9k
            goto op_semantics_55;
8765
0
            break;
8766
24.9k
        }
8767
0
      break;
8768
27.2k
    case 0xec:
8769
27.2k
        GETBYTE ();
8770
27.2k
        switch (op[1] & 0x00)
8771
27.2k
        {
8772
27.2k
          case 0x00:
8773
27.2k
            goto op_semantics_55;
8774
0
            break;
8775
27.2k
        }
8776
0
      break;
8777
22.8k
    case 0xed:
8778
22.8k
        GETBYTE ();
8779
22.8k
        switch (op[1] & 0x00)
8780
22.8k
        {
8781
22.7k
          case 0x00:
8782
22.7k
            goto op_semantics_55;
8783
0
            break;
8784
22.8k
        }
8785
0
      break;
8786
34.5k
    case 0xee:
8787
34.5k
        GETBYTE ();
8788
34.5k
        switch (op[1] & 0x00)
8789
34.5k
        {
8790
34.5k
          case 0x00:
8791
34.5k
            goto op_semantics_55;
8792
0
            break;
8793
34.5k
        }
8794
0
      break;
8795
30.2k
    case 0xef:
8796
30.2k
        GETBYTE ();
8797
30.2k
        switch (op[1] & 0x00)
8798
30.2k
        {
8799
30.2k
          case 0x00:
8800
30.2k
            goto op_semantics_55;
8801
0
            break;
8802
30.2k
        }
8803
0
      break;
8804
41.3k
    case 0xf0:
8805
41.3k
        GETBYTE ();
8806
41.3k
        switch (op[1] & 0x08)
8807
41.3k
        {
8808
25.1k
          case 0x00:
8809
90.8k
            op_semantics_56:
8810
90.8k
              {
8811
                /** 1111 00sd rdst 0bit     bset  #%1, %0%S0 */
8812
90.8k
#line 960 "rx-decode.opc"
8813
90.8k
                int sd AU = op[0] & 0x03;
8814
90.8k
#line 960 "rx-decode.opc"
8815
90.8k
                int rdst AU = (op[1] >> 4) & 0x0f;
8816
90.8k
#line 960 "rx-decode.opc"
8817
90.8k
                int bit AU = op[1] & 0x07;
8818
90.8k
                if (trace)
8819
0
                  {
8820
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8821
0
                           "/** 1111 00sd rdst 0bit     bset  #%1, %0%S0 */",
8822
0
                           op[0], op[1]);
8823
0
                    printf ("  sd = 0x%x,", sd);
8824
0
                    printf ("  rdst = 0x%x,", rdst);
8825
0
                    printf ("  bit = 0x%x\n", bit);
8826
0
                  }
8827
90.8k
                SYNTAX("bset  #%1, %0%S0");
8828
90.8k
#line 960 "rx-decode.opc"
8829
90.8k
                ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830
8831
90.8k
              }
8832
90.8k
            break;
8833
16.1k
          case 0x08:
8834
45.8k
            op_semantics_57:
8835
45.8k
              {
8836
                /** 1111 00sd rdst 1bit     bclr  #%1, %0%S0 */
8837
45.8k
#line 972 "rx-decode.opc"
8838
45.8k
                int sd AU = op[0] & 0x03;
8839
45.8k
#line 972 "rx-decode.opc"
8840
45.8k
                int rdst AU = (op[1] >> 4) & 0x0f;
8841
45.8k
#line 972 "rx-decode.opc"
8842
45.8k
                int bit AU = op[1] & 0x07;
8843
45.8k
                if (trace)
8844
0
                  {
8845
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8846
0
                           "/** 1111 00sd rdst 1bit     bclr  #%1, %0%S0 */",
8847
0
                           op[0], op[1]);
8848
0
                    printf ("  sd = 0x%x,", sd);
8849
0
                    printf ("  rdst = 0x%x,", rdst);
8850
0
                    printf ("  bit = 0x%x\n", bit);
8851
0
                  }
8852
45.8k
                SYNTAX("bclr  #%1, %0%S0");
8853
45.8k
#line 972 "rx-decode.opc"
8854
45.8k
                ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855
8856
45.8k
              }
8857
45.8k
            break;
8858
41.3k
        }
8859
136k
      break;
8860
136k
    case 0xf1:
8861
21.5k
        GETBYTE ();
8862
21.5k
        switch (op[1] & 0x08)
8863
21.5k
        {
8864
14.9k
          case 0x00:
8865
14.9k
            goto op_semantics_56;
8866
0
            break;
8867
6.59k
          case 0x08:
8868
6.59k
            goto op_semantics_57;
8869
0
            break;
8870
21.5k
        }
8871
0
      break;
8872
32.7k
    case 0xf2:
8873
32.7k
        GETBYTE ();
8874
32.7k
        switch (op[1] & 0x08)
8875
32.7k
        {
8876
21.0k
          case 0x00:
8877
21.0k
            goto op_semantics_56;
8878
0
            break;
8879
11.7k
          case 0x08:
8880
11.7k
            goto op_semantics_57;
8881
0
            break;
8882
32.7k
        }
8883
0
      break;
8884
41.0k
    case 0xf3:
8885
41.0k
        GETBYTE ();
8886
41.0k
        switch (op[1] & 0x08)
8887
41.0k
        {
8888
29.6k
          case 0x00:
8889
29.6k
            goto op_semantics_56;
8890
0
            break;
8891
11.4k
          case 0x08:
8892
11.4k
            goto op_semantics_57;
8893
0
            break;
8894
41.0k
        }
8895
0
      break;
8896
25.0k
    case 0xf4:
8897
25.0k
        GETBYTE ();
8898
25.0k
        switch (op[1] & 0x0c)
8899
25.0k
        {
8900
7.92k
          case 0x00:
8901
14.4k
          case 0x04:
8902
57.8k
            op_semantics_58:
8903
57.8k
              {
8904
                /** 1111 01sd rdst 0bit     btst  #%2, %1%S1 */
8905
57.8k
#line 984 "rx-decode.opc"
8906
57.8k
                int sd AU = op[0] & 0x03;
8907
57.8k
#line 984 "rx-decode.opc"
8908
57.8k
                int rdst AU = (op[1] >> 4) & 0x0f;
8909
57.8k
#line 984 "rx-decode.opc"
8910
57.8k
                int bit AU = op[1] & 0x07;
8911
57.8k
                if (trace)
8912
0
                  {
8913
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8914
0
                           "/** 1111 01sd rdst 0bit     btst  #%2, %1%S1 */",
8915
0
                           op[0], op[1]);
8916
0
                    printf ("  sd = 0x%x,", sd);
8917
0
                    printf ("  rdst = 0x%x,", rdst);
8918
0
                    printf ("  bit = 0x%x\n", bit);
8919
0
                  }
8920
57.8k
                SYNTAX("btst  #%2, %1%S1");
8921
57.8k
#line 984 "rx-decode.opc"
8922
57.8k
                ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923
8924
57.8k
              }
8925
57.8k
            break;
8926
5.16k
          case 0x08:
8927
22.5k
            op_semantics_59:
8928
22.5k
              {
8929
                /** 1111 01ss rsrc 10sz   push%s  %1 */
8930
22.5k
#line 402 "rx-decode.opc"
8931
22.5k
                int ss AU = op[0] & 0x03;
8932
22.5k
#line 402 "rx-decode.opc"
8933
22.5k
                int rsrc AU = (op[1] >> 4) & 0x0f;
8934
22.5k
#line 402 "rx-decode.opc"
8935
22.5k
                int sz AU = op[1] & 0x03;
8936
22.5k
                if (trace)
8937
0
                  {
8938
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
8939
0
                           "/** 1111 01ss rsrc 10sz   push%s  %1 */",
8940
0
                           op[0], op[1]);
8941
0
                    printf ("  ss = 0x%x,", ss);
8942
0
                    printf ("  rsrc = 0x%x,", rsrc);
8943
0
                    printf ("  sz = 0x%x\n", sz);
8944
0
                  }
8945
22.5k
                SYNTAX("push%s  %1");
8946
22.5k
#line 402 "rx-decode.opc"
8947
22.5k
                ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948
8949
              /*----------------------------------------------------------------------*/
8950
              /* XCHG                 */
8951
8952
22.5k
              }
8953
22.5k
            break;
8954
5.41k
          default: UNSUPPORTED(); break;
8955
25.0k
        }
8956
85.8k
      break;
8957
85.8k
    case 0xf5:
8958
25.9k
        GETBYTE ();
8959
25.9k
        switch (op[1] & 0x0c)
8960
25.9k
        {
8961
4.71k
          case 0x00:
8962
17.2k
          case 0x04:
8963
17.2k
            goto op_semantics_58;
8964
0
            break;
8965
3.29k
          case 0x08:
8966
3.29k
            goto op_semantics_59;
8967
0
            break;
8968
5.37k
          default: UNSUPPORTED(); break;
8969
25.9k
        }
8970
5.37k
      break;
8971
26.6k
    case 0xf6:
8972
26.6k
        GETBYTE ();
8973
26.6k
        switch (op[1] & 0x0c)
8974
26.6k
        {
8975
6.08k
          case 0x00:
8976
12.4k
          case 0x04:
8977
12.4k
            goto op_semantics_58;
8978
0
            break;
8979
10.5k
          case 0x08:
8980
10.5k
            goto op_semantics_59;
8981
0
            break;
8982
3.60k
          default: UNSUPPORTED(); break;
8983
26.6k
        }
8984
3.60k
      break;
8985
23.9k
    case 0xf7:
8986
23.9k
        GETBYTE ();
8987
23.9k
        switch (op[1] & 0x0c)
8988
23.9k
        {
8989
6.33k
          case 0x00:
8990
13.6k
          case 0x04:
8991
13.6k
            goto op_semantics_58;
8992
0
            break;
8993
3.52k
          case 0x08:
8994
3.52k
            goto op_semantics_59;
8995
0
            break;
8996
6.80k
          default: UNSUPPORTED(); break;
8997
23.9k
        }
8998
6.80k
      break;
8999
45.9k
    case 0xf8:
9000
45.9k
        GETBYTE ();
9001
45.9k
        switch (op[1] & 0x00)
9002
45.9k
        {
9003
45.9k
          case 0x00:
9004
158k
            op_semantics_60:
9005
158k
              {
9006
                /** 1111 10sd rdst im sz  mov%s #%1, %0 */
9007
158k
#line 313 "rx-decode.opc"
9008
158k
                int sd AU = op[0] & 0x03;
9009
158k
#line 313 "rx-decode.opc"
9010
158k
                int rdst AU = (op[1] >> 4) & 0x0f;
9011
158k
#line 313 "rx-decode.opc"
9012
158k
                int im AU = (op[1] >> 2) & 0x03;
9013
158k
#line 313 "rx-decode.opc"
9014
158k
                int sz AU = op[1] & 0x03;
9015
158k
                if (trace)
9016
0
                  {
9017
0
                    printf ("\033[33m%s\033[0m  %02x %02x\n",
9018
0
                           "/** 1111 10sd rdst im sz  mov%s #%1, %0 */",
9019
0
                           op[0], op[1]);
9020
0
                    printf ("  sd = 0x%x,", sd);
9021
0
                    printf ("  rdst = 0x%x,", rdst);
9022
0
                    printf ("  im = 0x%x,", im);
9023
0
                    printf ("  sz = 0x%x\n", sz);
9024
0
                  }
9025
158k
                SYNTAX("mov%s #%1, %0");
9026
158k
#line 313 "rx-decode.opc"
9027
158k
                ID(mov); DD(sd, rdst, sz);
9028
158k
                if ((im == 1 && sz == 0)
9029
158k
                    || (im == 2 && sz == 1)
9030
158k
                    || (im == 0 && sz == 2))
9031
36.2k
                  {
9032
36.2k
                    BWL (sz);
9033
36.2k
                    SC(IMM(im));
9034
36.2k
                  }
9035
122k
                else
9036
122k
                  {
9037
122k
                    sBWL (sz);
9038
122k
                    SC(IMMex(im));
9039
122k
                  }
9040
158k
                 F_____;
9041
9042
158k
              }
9043
158k
            break;
9044
45.9k
        }
9045
158k
      break;
9046
158k
    case 0xf9:
9047
62.1k
        GETBYTE ();
9048
62.1k
        switch (op[1] & 0xff)
9049
62.1k
        {
9050
1.52k
          case 0x00:
9051
2.62k
          case 0x01:
9052
2.80k
          case 0x02:
9053
2.86k
          case 0x04:
9054
3.44k
          case 0x05:
9055
3.76k
          case 0x06:
9056
3.85k
          case 0x08:
9057
4.02k
          case 0x09:
9058
4.29k
          case 0x0a:
9059
4.40k
          case 0x0c:
9060
4.45k
          case 0x0d:
9061
4.48k
          case 0x0e:
9062
4.55k
          case 0x10:
9063
4.63k
          case 0x11:
9064
5.15k
          case 0x12:
9065
5.22k
          case 0x14:
9066
5.27k
          case 0x15:
9067
5.31k
          case 0x16:
9068
5.49k
          case 0x18:
9069
5.51k
          case 0x19:
9070
5.57k
          case 0x1a:
9071
5.60k
          case 0x1c:
9072
5.85k
          case 0x1d:
9073
6.02k
          case 0x1e:
9074
6.10k
          case 0x20:
9075
6.18k
          case 0x21:
9076
6.27k
          case 0x22:
9077
6.75k
          case 0x24:
9078
6.90k
          case 0x25:
9079
6.93k
          case 0x26:
9080
7.12k
          case 0x28:
9081
7.24k
          case 0x29:
9082
7.47k
          case 0x2a:
9083
7.60k
          case 0x2c:
9084
8.11k
          case 0x2d:
9085
8.27k
          case 0x2e:
9086
8.43k
          case 0x30:
9087
8.52k
          case 0x31:
9088
8.97k
          case 0x32:
9089
9.05k
          case 0x34:
9090
9.11k
          case 0x35:
9091
9.28k
          case 0x36:
9092
9.38k
          case 0x38:
9093
9.58k
          case 0x39:
9094
9.86k
          case 0x3a:
9095
9.90k
          case 0x3c:
9096
9.97k
          case 0x3d:
9097
10.0k
          case 0x3e:
9098
10.1k
          case 0x40:
9099
10.9k
          case 0x41:
9100
11.1k
          case 0x42:
9101
11.3k
          case 0x44:
9102
11.3k
          case 0x45:
9103
11.5k
          case 0x46:
9104
12.3k
          case 0x48:
9105
12.4k
          case 0x49:
9106
12.5k
          case 0x4a:
9107
12.6k
          case 0x4c:
9108
12.7k
          case 0x4d:
9109
12.7k
          case 0x4e:
9110
13.3k
          case 0x50:
9111
13.3k
          case 0x51:
9112
13.4k
          case 0x52:
9113
13.5k
          case 0x54:
9114
13.7k
          case 0x55:
9115
13.9k
          case 0x56:
9116
13.9k
          case 0x58:
9117
13.9k
          case 0x59:
9118
13.9k
          case 0x5a:
9119
14.0k
          case 0x5c:
9120
14.4k
          case 0x5d:
9121
14.5k
          case 0x5e:
9122
14.6k
          case 0x60:
9123
14.6k
          case 0x61:
9124
14.7k
          case 0x62:
9125
14.9k
          case 0x64:
9126
15.0k
          case 0x65:
9127
15.0k
          case 0x66:
9128
15.1k
          case 0x68:
9129
15.2k
          case 0x69:
9130
15.3k
          case 0x6a:
9131
15.5k
          case 0x6c:
9132
15.5k
          case 0x6d:
9133
15.6k
          case 0x6e:
9134
15.7k
          case 0x70:
9135
15.8k
          case 0x71:
9136
15.9k
          case 0x72:
9137
17.2k
          case 0x74:
9138
17.6k
          case 0x75:
9139
17.8k
          case 0x76:
9140
18.0k
          case 0x78:
9141
18.2k
          case 0x79:
9142
18.3k
          case 0x7a:
9143
18.5k
          case 0x7c:
9144
18.6k
          case 0x7d:
9145
18.7k
          case 0x7e:
9146
19.3k
          case 0x80:
9147
19.3k
          case 0x81:
9148
19.4k
          case 0x82:
9149
19.6k
          case 0x84:
9150
19.7k
          case 0x85:
9151
20.3k
          case 0x86:
9152
20.4k
          case 0x88:
9153
20.5k
          case 0x89:
9154
20.6k
          case 0x8a:
9155
20.6k
          case 0x8c:
9156
20.7k
          case 0x8d:
9157
20.9k
          case 0x8e:
9158
21.0k
          case 0x90:
9159
21.2k
          case 0x91:
9160
21.2k
          case 0x92:
9161
21.2k
          case 0x94:
9162
21.3k
          case 0x95:
9163
21.7k
          case 0x96:
9164
22.0k
          case 0x98:
9165
22.0k
          case 0x99:
9166
22.1k
          case 0x9a:
9167
22.1k
          case 0x9c:
9168
22.2k
          case 0x9d:
9169
22.2k
          case 0x9e:
9170
22.2k
          case 0xa0:
9171
22.5k
          case 0xa1:
9172
22.6k
          case 0xa2:
9173
22.7k
          case 0xa4:
9174
22.8k
          case 0xa5:
9175
22.8k
          case 0xa6:
9176
23.0k
          case 0xa8:
9177
23.1k
          case 0xa9:
9178
23.6k
          case 0xaa:
9179
23.7k
          case 0xac:
9180
23.7k
          case 0xad:
9181
23.8k
          case 0xae:
9182
23.8k
          case 0xb0:
9183
23.8k
          case 0xb1:
9184
23.9k
          case 0xb2:
9185
23.9k
          case 0xb4:
9186
23.9k
          case 0xb5:
9187
24.0k
          case 0xb6:
9188
24.1k
          case 0xb8:
9189
24.2k
          case 0xb9:
9190
24.3k
          case 0xba:
9191
24.5k
          case 0xbc:
9192
24.8k
          case 0xbd:
9193
25.0k
          case 0xbe:
9194
25.0k
          case 0xc0:
9195
25.0k
          case 0xc1:
9196
25.1k
          case 0xc2:
9197
25.1k
          case 0xc4:
9198
25.2k
          case 0xc5:
9199
25.5k
          case 0xc6:
9200
25.6k
          case 0xc8:
9201
25.6k
          case 0xc9:
9202
25.8k
          case 0xca:
9203
25.9k
          case 0xcc:
9204
26.1k
          case 0xcd:
9205
26.1k
          case 0xce:
9206
26.2k
          case 0xd0:
9207
26.2k
          case 0xd1:
9208
26.2k
          case 0xd2:
9209
26.3k
          case 0xd4:
9210
26.6k
          case 0xd5:
9211
26.7k
          case 0xd6:
9212
26.7k
          case 0xd8:
9213
27.0k
          case 0xd9:
9214
27.0k
          case 0xda:
9215
27.1k
          case 0xdc:
9216
27.2k
          case 0xdd:
9217
27.7k
          case 0xde:
9218
28.0k
          case 0xe0:
9219
28.2k
          case 0xe1:
9220
28.5k
          case 0xe2:
9221
29.3k
          case 0xe4:
9222
29.4k
          case 0xe5:
9223
29.7k
          case 0xe6:
9224
29.7k
          case 0xe8:
9225
29.9k
          case 0xe9:
9226
29.9k
          case 0xea:
9227
30.0k
          case 0xec:
9228
30.1k
          case 0xed:
9229
30.2k
          case 0xee:
9230
30.7k
          case 0xf0:
9231
30.7k
          case 0xf1:
9232
30.8k
          case 0xf2:
9233
31.2k
          case 0xf4:
9234
31.4k
          case 0xf5:
9235
31.5k
          case 0xf6:
9236
35.4k
          case 0xf8:
9237
49.9k
          case 0xf9:
9238
50.0k
          case 0xfa:
9239
50.0k
          case 0xfc:
9240
50.4k
          case 0xfd:
9241
50.6k
          case 0xfe:
9242
50.6k
            goto op_semantics_60;
9243
0
            break;
9244
568
          case 0x03:
9245
568
              GETBYTE ();
9246
568
              switch (op[2] & 0x0f)
9247
568
              {
9248
42
                case 0x00:
9249
42
                    {
9250
                      /** 1111 1001 0000 0011 rdst 0000 dmov.l  #%1, %0 */
9251
42
#line 1211 "rx-decode.opc"
9252
42
                      int rdst AU = (op[2] >> 4) & 0x0f;
9253
42
                      if (trace)
9254
0
                        {
9255
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9256
0
                                 "/** 1111 1001 0000 0011 rdst 0000 dmov.l  #%1, %0 */",
9257
0
                                 op[0], op[1], op[2]);
9258
0
                          printf ("  rdst = 0x%x\n", rdst);
9259
0
                        }
9260
42
                      SYNTAX("dmov.l  #%1, %0");
9261
42
#line 1211 "rx-decode.opc"
9262
42
                      ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263
9264
42
                    }
9265
42
                  break;
9266
17
                case 0x02:
9267
192
                case 0x03:
9268
192
                    {
9269
                      /** 1111 1001 0000 0011 rdst 001s dmov%s  #%1, %0 */
9270
192
#line 1208 "rx-decode.opc"
9271
192
                      int rdst AU = (op[2] >> 4) & 0x0f;
9272
192
#line 1208 "rx-decode.opc"
9273
192
                      int s AU = op[2] & 0x01;
9274
192
                      if (trace)
9275
0
                        {
9276
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9277
0
                                 "/** 1111 1001 0000 0011 rdst 001s dmov%s  #%1, %0 */",
9278
0
                                 op[0], op[1], op[2]);
9279
0
                          printf ("  rdst = 0x%x,", rdst);
9280
0
                          printf ("  s = 0x%x\n", s);
9281
0
                        }
9282
192
                      SYNTAX("dmov%s  #%1, %0");
9283
192
#line 1208 "rx-decode.opc"
9284
192
                      ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285
9286
192
                    }
9287
192
                  break;
9288
334
                default: UNSUPPORTED(); break;
9289
568
              }
9290
568
            break;
9291
10.9k
          default: UNSUPPORTED(); break;
9292
62.1k
        }
9293
11.4k
      break;
9294
25.8k
    case 0xfa:
9295
25.8k
        GETBYTE ();
9296
25.8k
        switch (op[1] & 0x00)
9297
25.8k
        {
9298
25.8k
          case 0x00:
9299
25.8k
            goto op_semantics_60;
9300
0
            break;
9301
25.8k
        }
9302
0
      break;
9303
36.4k
    case 0xfb:
9304
36.4k
        GETBYTE ();
9305
36.4k
        switch (op[1] & 0x00)
9306
36.4k
        {
9307
36.4k
          case 0x00:
9308
36.4k
            goto op_semantics_60;
9309
0
            break;
9310
36.4k
        }
9311
0
      break;
9312
105k
    case 0xfc:
9313
105k
        GETBYTE ();
9314
105k
        switch (op[1] & 0xff)
9315
105k
        {
9316
1.51k
          case 0x03:
9317
1.51k
              GETBYTE ();
9318
1.51k
              switch (op[2] & 0x00)
9319
1.51k
              {
9320
1.51k
                case 0x00:
9321
1.51k
                    {
9322
                      /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
9323
1.51k
#line 576 "rx-decode.opc"
9324
1.51k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9325
1.51k
#line 576 "rx-decode.opc"
9326
1.51k
                      int rdst AU = op[2] & 0x0f;
9327
1.51k
                      if (trace)
9328
0
                        {
9329
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9330
0
                                 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
9331
0
                                 op[0], op[1], op[2]);
9332
0
                          printf ("  rsrc = 0x%x,", rsrc);
9333
0
                          printf ("  rdst = 0x%x\n", rdst);
9334
0
                        }
9335
1.51k
                      SYNTAX("sbb %1, %0");
9336
1.51k
#line 576 "rx-decode.opc"
9337
1.51k
                      ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338
9339
                      /* FIXME: only supports .L */
9340
1.51k
                    }
9341
1.51k
                  break;
9342
1.51k
              }
9343
1.51k
            break;
9344
1.51k
          case 0x07:
9345
50
              GETBYTE ();
9346
50
              switch (op[2] & 0x00)
9347
50
              {
9348
50
                case 0x00:
9349
50
                    {
9350
                      /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
9351
50
#line 507 "rx-decode.opc"
9352
50
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9353
50
#line 507 "rx-decode.opc"
9354
50
                      int rdst AU = op[2] & 0x0f;
9355
50
                      if (trace)
9356
0
                        {
9357
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9358
0
                                 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
9359
0
                                 op[0], op[1], op[2]);
9360
0
                          printf ("  rsrc = 0x%x,", rsrc);
9361
0
                          printf ("  rdst = 0x%x\n", rdst);
9362
0
                        }
9363
50
                      SYNTAX("neg %2, %0");
9364
50
#line 507 "rx-decode.opc"
9365
50
                      ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366
9367
                    /*----------------------------------------------------------------------*/
9368
                    /* ADC                  */
9369
9370
50
                    }
9371
50
                  break;
9372
50
              }
9373
50
            break;
9374
88
          case 0x0b:
9375
88
              GETBYTE ();
9376
88
              switch (op[2] & 0x00)
9377
88
              {
9378
88
                case 0x00:
9379
88
                    {
9380
                      /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
9381
88
#line 516 "rx-decode.opc"
9382
88
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9383
88
#line 516 "rx-decode.opc"
9384
88
                      int rdst AU = op[2] & 0x0f;
9385
88
                      if (trace)
9386
0
                        {
9387
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9388
0
                                 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
9389
0
                                 op[0], op[1], op[2]);
9390
0
                          printf ("  rsrc = 0x%x,", rsrc);
9391
0
                          printf ("  rdst = 0x%x\n", rdst);
9392
0
                        }
9393
88
                      SYNTAX("adc %1, %0");
9394
88
#line 516 "rx-decode.opc"
9395
88
                      ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396
9397
88
                    }
9398
88
                  break;
9399
88
              }
9400
88
            break;
9401
233
          case 0x0f:
9402
233
              GETBYTE ();
9403
233
              switch (op[2] & 0x00)
9404
233
              {
9405
233
                case 0x00:
9406
233
                    {
9407
                      /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
9408
233
#line 589 "rx-decode.opc"
9409
233
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9410
233
#line 589 "rx-decode.opc"
9411
233
                      int rdst AU = op[2] & 0x0f;
9412
233
                      if (trace)
9413
0
                        {
9414
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9415
0
                                 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
9416
0
                                 op[0], op[1], op[2]);
9417
0
                          printf ("  rsrc = 0x%x,", rsrc);
9418
0
                          printf ("  rdst = 0x%x\n", rdst);
9419
0
                        }
9420
233
                      SYNTAX("abs %1, %0");
9421
233
#line 589 "rx-decode.opc"
9422
233
                      ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423
9424
                    /*----------------------------------------------------------------------*/
9425
                    /* MAX                  */
9426
9427
233
                    }
9428
233
                  break;
9429
233
              }
9430
233
            break;
9431
233
          case 0x10:
9432
167
              GETBYTE ();
9433
167
              switch (op[2] & 0x00)
9434
167
              {
9435
167
                case 0x00:
9436
752
                  op_semantics_61:
9437
752
                    {
9438
                      /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
9439
752
#line 608 "rx-decode.opc"
9440
752
                      int ss AU = op[1] & 0x03;
9441
752
#line 608 "rx-decode.opc"
9442
752
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9443
752
#line 608 "rx-decode.opc"
9444
752
                      int rdst AU = op[2] & 0x0f;
9445
752
                      if (trace)
9446
0
                        {
9447
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9448
0
                                 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
9449
0
                                 op[0], op[1], op[2]);
9450
0
                          printf ("  ss = 0x%x,", ss);
9451
0
                          printf ("  rsrc = 0x%x,", rsrc);
9452
0
                          printf ("  rdst = 0x%x\n", rdst);
9453
0
                        }
9454
752
                      SYNTAX("max %1%S1, %0");
9455
752
#line 608 "rx-decode.opc"
9456
752
                      if (ss == 3 && rsrc == 0 && rdst == 0)
9457
81
                        {
9458
81
                          ID(nop3);
9459
81
                          SYNTAX("nop\t; max\tr0, r0");
9460
81
                        }
9461
671
                      else
9462
671
                        {
9463
671
                          ID(max); SP(ss, rsrc); DR(rdst);
9464
671
                        }
9465
9466
752
                    }
9467
752
                  break;
9468
167
              }
9469
752
            break;
9470
752
          case 0x11:
9471
352
              GETBYTE ();
9472
352
              switch (op[2] & 0x00)
9473
352
              {
9474
352
                case 0x00:
9475
352
                  goto op_semantics_61;
9476
0
                  break;
9477
352
              }
9478
0
            break;
9479
87
          case 0x12:
9480
87
              GETBYTE ();
9481
87
              switch (op[2] & 0x00)
9482
87
              {
9483
87
                case 0x00:
9484
87
                  goto op_semantics_61;
9485
0
                  break;
9486
87
              }
9487
0
            break;
9488
146
          case 0x13:
9489
146
              GETBYTE ();
9490
146
              switch (op[2] & 0x00)
9491
146
              {
9492
146
                case 0x00:
9493
146
                  goto op_semantics_61;
9494
0
                  break;
9495
146
              }
9496
0
            break;
9497
127
          case 0x14:
9498
127
              GETBYTE ();
9499
127
              switch (op[2] & 0x00)
9500
127
              {
9501
127
                case 0x00:
9502
361
                  op_semantics_62:
9503
361
                    {
9504
                      /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
9505
361
#line 628 "rx-decode.opc"
9506
361
                      int ss AU = op[1] & 0x03;
9507
361
#line 628 "rx-decode.opc"
9508
361
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9509
361
#line 628 "rx-decode.opc"
9510
361
                      int rdst AU = op[2] & 0x0f;
9511
361
                      if (trace)
9512
0
                        {
9513
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9514
0
                                 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
9515
0
                                 op[0], op[1], op[2]);
9516
0
                          printf ("  ss = 0x%x,", ss);
9517
0
                          printf ("  rsrc = 0x%x,", rsrc);
9518
0
                          printf ("  rdst = 0x%x\n", rdst);
9519
0
                        }
9520
361
                      SYNTAX("min %1%S1, %0");
9521
361
#line 628 "rx-decode.opc"
9522
361
                      ID(min); SP(ss, rsrc); DR(rdst);
9523
9524
361
                    }
9525
361
                  break;
9526
127
              }
9527
361
            break;
9528
361
          case 0x15:
9529
89
              GETBYTE ();
9530
89
              switch (op[2] & 0x00)
9531
89
              {
9532
83
                case 0x00:
9533
83
                  goto op_semantics_62;
9534
0
                  break;
9535
89
              }
9536
0
            break;
9537
75
          case 0x16:
9538
75
              GETBYTE ();
9539
75
              switch (op[2] & 0x00)
9540
75
              {
9541
75
                case 0x00:
9542
75
                  goto op_semantics_62;
9543
0
                  break;
9544
75
              }
9545
0
            break;
9546
76
          case 0x17:
9547
76
              GETBYTE ();
9548
76
              switch (op[2] & 0x00)
9549
76
              {
9550
76
                case 0x00:
9551
76
                  goto op_semantics_62;
9552
0
                  break;
9553
76
              }
9554
0
            break;
9555
141
          case 0x18:
9556
141
              GETBYTE ();
9557
141
              switch (op[2] & 0x00)
9558
141
              {
9559
141
                case 0x00:
9560
671
                  op_semantics_63:
9561
671
                    {
9562
                      /** 1111 1100 0001 10ss rsrc rdst emul  %1%S1, %0 */
9563
671
#line 686 "rx-decode.opc"
9564
671
                      int ss AU = op[1] & 0x03;
9565
671
#line 686 "rx-decode.opc"
9566
671
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9567
671
#line 686 "rx-decode.opc"
9568
671
                      int rdst AU = op[2] & 0x0f;
9569
671
                      if (trace)
9570
0
                        {
9571
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9572
0
                                 "/** 1111 1100 0001 10ss rsrc rdst emul  %1%S1, %0 */",
9573
0
                                 op[0], op[1], op[2]);
9574
0
                          printf ("  ss = 0x%x,", ss);
9575
0
                          printf ("  rsrc = 0x%x,", rsrc);
9576
0
                          printf ("  rdst = 0x%x\n", rdst);
9577
0
                        }
9578
671
                      SYNTAX("emul  %1%S1, %0");
9579
671
#line 686 "rx-decode.opc"
9580
671
                      ID(emul); SP(ss, rsrc); DR(rdst);
9581
9582
671
                    }
9583
671
                  break;
9584
141
              }
9585
671
            break;
9586
671
          case 0x19:
9587
170
              GETBYTE ();
9588
170
              switch (op[2] & 0x00)
9589
170
              {
9590
170
                case 0x00:
9591
170
                  goto op_semantics_63;
9592
0
                  break;
9593
170
              }
9594
0
            break;
9595
295
          case 0x1a:
9596
295
              GETBYTE ();
9597
295
              switch (op[2] & 0x00)
9598
295
              {
9599
295
                case 0x00:
9600
295
                  goto op_semantics_63;
9601
0
                  break;
9602
295
              }
9603
0
            break;
9604
65
          case 0x1b:
9605
65
              GETBYTE ();
9606
65
              switch (op[2] & 0x00)
9607
65
              {
9608
65
                case 0x00:
9609
65
                  goto op_semantics_63;
9610
0
                  break;
9611
65
              }
9612
0
            break;
9613
67
          case 0x1c:
9614
67
              GETBYTE ();
9615
67
              switch (op[2] & 0x00)
9616
67
              {
9617
67
                case 0x00:
9618
770
                  op_semantics_64:
9619
770
                    {
9620
                      /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
9621
770
#line 698 "rx-decode.opc"
9622
770
                      int ss AU = op[1] & 0x03;
9623
770
#line 698 "rx-decode.opc"
9624
770
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9625
770
#line 698 "rx-decode.opc"
9626
770
                      int rdst AU = op[2] & 0x0f;
9627
770
                      if (trace)
9628
0
                        {
9629
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9630
0
                                 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
9631
0
                                 op[0], op[1], op[2]);
9632
0
                          printf ("  ss = 0x%x,", ss);
9633
0
                          printf ("  rsrc = 0x%x,", rsrc);
9634
0
                          printf ("  rdst = 0x%x\n", rdst);
9635
0
                        }
9636
770
                      SYNTAX("emulu %1%S1, %0");
9637
770
#line 698 "rx-decode.opc"
9638
770
                      ID(emulu); SP(ss, rsrc); DR(rdst);
9639
9640
770
                    }
9641
770
                  break;
9642
67
              }
9643
770
            break;
9644
770
          case 0x1d:
9645
263
              GETBYTE ();
9646
263
              switch (op[2] & 0x00)
9647
263
              {
9648
263
                case 0x00:
9649
263
                  goto op_semantics_64;
9650
0
                  break;
9651
263
              }
9652
0
            break;
9653
362
          case 0x1e:
9654
362
              GETBYTE ();
9655
362
              switch (op[2] & 0x00)
9656
362
              {
9657
362
                case 0x00:
9658
362
                  goto op_semantics_64;
9659
0
                  break;
9660
362
              }
9661
0
            break;
9662
78
          case 0x1f:
9663
78
              GETBYTE ();
9664
78
              switch (op[2] & 0x00)
9665
78
              {
9666
78
                case 0x00:
9667
78
                  goto op_semantics_64;
9668
0
                  break;
9669
78
              }
9670
0
            break;
9671
398
          case 0x20:
9672
398
              GETBYTE ();
9673
398
              switch (op[2] & 0x00)
9674
398
              {
9675
398
                case 0x00:
9676
688
                  op_semantics_65:
9677
688
                    {
9678
                      /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
9679
688
#line 710 "rx-decode.opc"
9680
688
                      int ss AU = op[1] & 0x03;
9681
688
#line 710 "rx-decode.opc"
9682
688
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9683
688
#line 710 "rx-decode.opc"
9684
688
                      int rdst AU = op[2] & 0x0f;
9685
688
                      if (trace)
9686
0
                        {
9687
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9688
0
                                 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
9689
0
                                 op[0], op[1], op[2]);
9690
0
                          printf ("  ss = 0x%x,", ss);
9691
0
                          printf ("  rsrc = 0x%x,", rsrc);
9692
0
                          printf ("  rdst = 0x%x\n", rdst);
9693
0
                        }
9694
688
                      SYNTAX("div %1%S1, %0");
9695
688
#line 710 "rx-decode.opc"
9696
688
                      ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697
9698
688
                    }
9699
688
                  break;
9700
398
              }
9701
688
            break;
9702
688
          case 0x21:
9703
168
              GETBYTE ();
9704
168
              switch (op[2] & 0x00)
9705
168
              {
9706
168
                case 0x00:
9707
168
                  goto op_semantics_65;
9708
0
                  break;
9709
168
              }
9710
0
            break;
9711
88
          case 0x22:
9712
88
              GETBYTE ();
9713
88
              switch (op[2] & 0x00)
9714
88
              {
9715
88
                case 0x00:
9716
88
                  goto op_semantics_65;
9717
0
                  break;
9718
88
              }
9719
0
            break;
9720
37
          case 0x23:
9721
37
              GETBYTE ();
9722
37
              switch (op[2] & 0x00)
9723
37
              {
9724
34
                case 0x00:
9725
34
                  goto op_semantics_65;
9726
0
                  break;
9727
37
              }
9728
0
            break;
9729
33
          case 0x24:
9730
33
              GETBYTE ();
9731
33
              switch (op[2] & 0x00)
9732
33
              {
9733
33
                case 0x00:
9734
347
                  op_semantics_66:
9735
347
                    {
9736
                      /** 1111 1100 0010 01ss rsrc rdst divu  %1%S1, %0 */
9737
347
#line 722 "rx-decode.opc"
9738
347
                      int ss AU = op[1] & 0x03;
9739
347
#line 722 "rx-decode.opc"
9740
347
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9741
347
#line 722 "rx-decode.opc"
9742
347
                      int rdst AU = op[2] & 0x0f;
9743
347
                      if (trace)
9744
0
                        {
9745
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9746
0
                                 "/** 1111 1100 0010 01ss rsrc rdst divu  %1%S1, %0 */",
9747
0
                                 op[0], op[1], op[2]);
9748
0
                          printf ("  ss = 0x%x,", ss);
9749
0
                          printf ("  rsrc = 0x%x,", rsrc);
9750
0
                          printf ("  rdst = 0x%x\n", rdst);
9751
0
                        }
9752
347
                      SYNTAX("divu  %1%S1, %0");
9753
347
#line 722 "rx-decode.opc"
9754
347
                      ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755
9756
347
                    }
9757
347
                  break;
9758
33
              }
9759
347
            break;
9760
347
          case 0x25:
9761
20
              GETBYTE ();
9762
20
              switch (op[2] & 0x00)
9763
20
              {
9764
20
                case 0x00:
9765
20
                  goto op_semantics_66;
9766
0
                  break;
9767
20
              }
9768
0
            break;
9769
148
          case 0x26:
9770
148
              GETBYTE ();
9771
148
              switch (op[2] & 0x00)
9772
148
              {
9773
148
                case 0x00:
9774
148
                  goto op_semantics_66;
9775
0
                  break;
9776
148
              }
9777
0
            break;
9778
146
          case 0x27:
9779
146
              GETBYTE ();
9780
146
              switch (op[2] & 0x00)
9781
146
              {
9782
146
                case 0x00:
9783
146
                  goto op_semantics_66;
9784
0
                  break;
9785
146
              }
9786
0
            break;
9787
93
          case 0x30:
9788
93
              GETBYTE ();
9789
93
              switch (op[2] & 0x00)
9790
93
              {
9791
93
                case 0x00:
9792
469
                  op_semantics_67:
9793
469
                    {
9794
                      /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
9795
469
#line 495 "rx-decode.opc"
9796
469
                      int ss AU = op[1] & 0x03;
9797
469
#line 495 "rx-decode.opc"
9798
469
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9799
469
#line 495 "rx-decode.opc"
9800
469
                      int rdst AU = op[2] & 0x0f;
9801
469
                      if (trace)
9802
0
                        {
9803
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9804
0
                                 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
9805
0
                                 op[0], op[1], op[2]);
9806
0
                          printf ("  ss = 0x%x,", ss);
9807
0
                          printf ("  rsrc = 0x%x,", rsrc);
9808
0
                          printf ("  rdst = 0x%x\n", rdst);
9809
0
                        }
9810
469
                      SYNTAX("tst %1%S1, %2");
9811
469
#line 495 "rx-decode.opc"
9812
469
                      ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
9813
9814
469
                    }
9815
469
                  break;
9816
93
              }
9817
469
            break;
9818
469
          case 0x31:
9819
105
              GETBYTE ();
9820
105
              switch (op[2] & 0x00)
9821
105
              {
9822
105
                case 0x00:
9823
105
                  goto op_semantics_67;
9824
0
                  break;
9825
105
              }
9826
0
            break;
9827
173
          case 0x32:
9828
173
              GETBYTE ();
9829
173
              switch (op[2] & 0x00)
9830
173
              {
9831
173
                case 0x00:
9832
173
                  goto op_semantics_67;
9833
0
                  break;
9834
173
              }
9835
0
            break;
9836
98
          case 0x33:
9837
98
              GETBYTE ();
9838
98
              switch (op[2] & 0x00)
9839
98
              {
9840
98
                case 0x00:
9841
98
                  goto op_semantics_67;
9842
0
                  break;
9843
98
              }
9844
0
            break;
9845
67
          case 0x34:
9846
67
              GETBYTE ();
9847
67
              switch (op[2] & 0x00)
9848
67
              {
9849
66
                case 0x00:
9850
533
                  op_semantics_68:
9851
533
                    {
9852
                      /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
9853
533
#line 474 "rx-decode.opc"
9854
533
                      int ss AU = op[1] & 0x03;
9855
533
#line 474 "rx-decode.opc"
9856
533
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9857
533
#line 474 "rx-decode.opc"
9858
533
                      int rdst AU = op[2] & 0x0f;
9859
533
                      if (trace)
9860
0
                        {
9861
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9862
0
                                 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
9863
0
                                 op[0], op[1], op[2]);
9864
0
                          printf ("  ss = 0x%x,", ss);
9865
0
                          printf ("  rsrc = 0x%x,", rsrc);
9866
0
                          printf ("  rdst = 0x%x\n", rdst);
9867
0
                        }
9868
533
                      SYNTAX("xor %1%S1, %0");
9869
533
#line 474 "rx-decode.opc"
9870
533
                      ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871
9872
533
                    }
9873
533
                  break;
9874
67
              }
9875
533
            break;
9876
533
          case 0x35:
9877
317
              GETBYTE ();
9878
317
              switch (op[2] & 0x00)
9879
317
              {
9880
315
                case 0x00:
9881
315
                  goto op_semantics_68;
9882
0
                  break;
9883
317
              }
9884
0
            break;
9885
69
          case 0x36:
9886
69
              GETBYTE ();
9887
69
              switch (op[2] & 0x00)
9888
69
              {
9889
69
                case 0x00:
9890
69
                  goto op_semantics_68;
9891
0
                  break;
9892
69
              }
9893
0
            break;
9894
83
          case 0x37:
9895
83
              GETBYTE ();
9896
83
              switch (op[2] & 0x00)
9897
83
              {
9898
83
                case 0x00:
9899
83
                  goto op_semantics_68;
9900
0
                  break;
9901
83
              }
9902
0
            break;
9903
153
          case 0x3b:
9904
153
              GETBYTE ();
9905
153
              switch (op[2] & 0x00)
9906
153
              {
9907
153
                case 0x00:
9908
153
                    {
9909
                      /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
9910
153
#line 486 "rx-decode.opc"
9911
153
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9912
153
#line 486 "rx-decode.opc"
9913
153
                      int rdst AU = op[2] & 0x0f;
9914
153
                      if (trace)
9915
0
                        {
9916
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9917
0
                                 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
9918
0
                                 op[0], op[1], op[2]);
9919
0
                          printf ("  rsrc = 0x%x,", rsrc);
9920
0
                          printf ("  rdst = 0x%x\n", rdst);
9921
0
                        }
9922
153
                      SYNTAX("not %1, %0");
9923
153
#line 486 "rx-decode.opc"
9924
153
                      ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
9925
9926
                    /*----------------------------------------------------------------------*/
9927
                    /* TST                  */
9928
9929
153
                    }
9930
153
                  break;
9931
153
              }
9932
153
            break;
9933
1.73k
          case 0x40:
9934
1.73k
              GETBYTE ();
9935
1.73k
              switch (op[2] & 0x00)
9936
1.73k
              {
9937
1.73k
                case 0x00:
9938
2.33k
                  op_semantics_69:
9939
2.33k
                    {
9940
                      /** 1111 1100 0100 00ss rsrc rdst xchg  %1%S1, %0 */
9941
2.33k
#line 408 "rx-decode.opc"
9942
2.33k
                      int ss AU = op[1] & 0x03;
9943
2.33k
#line 408 "rx-decode.opc"
9944
2.33k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
9945
2.33k
#line 408 "rx-decode.opc"
9946
2.33k
                      int rdst AU = op[2] & 0x0f;
9947
2.33k
                      if (trace)
9948
0
                        {
9949
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9950
0
                                 "/** 1111 1100 0100 00ss rsrc rdst xchg  %1%S1, %0 */",
9951
0
                                 op[0], op[1], op[2]);
9952
0
                          printf ("  ss = 0x%x,", ss);
9953
0
                          printf ("  rsrc = 0x%x,", rsrc);
9954
0
                          printf ("  rdst = 0x%x\n", rdst);
9955
0
                        }
9956
2.33k
                      SYNTAX("xchg  %1%S1, %0");
9957
2.33k
#line 408 "rx-decode.opc"
9958
2.33k
                      ID(xchg); DR(rdst); SP(ss, rsrc);
9959
9960
2.33k
                    }
9961
2.33k
                  break;
9962
1.73k
              }
9963
2.33k
            break;
9964
2.33k
          case 0x41:
9965
52
              GETBYTE ();
9966
52
              switch (op[2] & 0x00)
9967
52
              {
9968
52
                case 0x00:
9969
52
                  goto op_semantics_69;
9970
0
                  break;
9971
52
              }
9972
0
            break;
9973
523
          case 0x42:
9974
523
              GETBYTE ();
9975
523
              switch (op[2] & 0x00)
9976
523
              {
9977
520
                case 0x00:
9978
520
                  goto op_semantics_69;
9979
0
                  break;
9980
523
              }
9981
0
            break;
9982
24
          case 0x43:
9983
24
              GETBYTE ();
9984
24
              switch (op[2] & 0x00)
9985
24
              {
9986
20
                case 0x00:
9987
20
                  goto op_semantics_69;
9988
0
                  break;
9989
24
              }
9990
0
            break;
9991
47
          case 0x44:
9992
47
              GETBYTE ();
9993
47
              switch (op[2] & 0x00)
9994
47
              {
9995
47
                case 0x00:
9996
276
                  op_semantics_70:
9997
276
                    {
9998
                      /** 1111 1100 0100 01sd rsrc rdst itof  %1%S1, %0 */
9999
276
#line 951 "rx-decode.opc"
10000
276
                      int sd AU = op[1] & 0x03;
10001
276
#line 951 "rx-decode.opc"
10002
276
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10003
276
#line 951 "rx-decode.opc"
10004
276
                      int rdst AU = op[2] & 0x0f;
10005
276
                      if (trace)
10006
0
                        {
10007
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10008
0
                                 "/** 1111 1100 0100 01sd rsrc rdst itof  %1%S1, %0 */",
10009
0
                                 op[0], op[1], op[2]);
10010
0
                          printf ("  sd = 0x%x,", sd);
10011
0
                          printf ("  rsrc = 0x%x,", rsrc);
10012
0
                          printf ("  rdst = 0x%x\n", rdst);
10013
0
                        }
10014
276
                      SYNTAX("itof  %1%S1, %0");
10015
276
#line 951 "rx-decode.opc"
10016
276
                      ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10017
10018
276
                    }
10019
276
                  break;
10020
47
              }
10021
276
            break;
10022
276
          case 0x45:
10023
34
              GETBYTE ();
10024
34
              switch (op[2] & 0x00)
10025
34
              {
10026
34
                case 0x00:
10027
34
                  goto op_semantics_70;
10028
0
                  break;
10029
34
              }
10030
0
            break;
10031
159
          case 0x46:
10032
159
              GETBYTE ();
10033
159
              switch (op[2] & 0x00)
10034
159
              {
10035
159
                case 0x00:
10036
159
                  goto op_semantics_70;
10037
0
                  break;
10038
159
              }
10039
0
            break;
10040
36
          case 0x47:
10041
36
              GETBYTE ();
10042
36
              switch (op[2] & 0x00)
10043
36
              {
10044
36
                case 0x00:
10045
36
                  goto op_semantics_70;
10046
0
                  break;
10047
36
              }
10048
0
            break;
10049
55
          case 0x4b:
10050
55
              GETBYTE ();
10051
55
              switch (op[2] & 0x00)
10052
55
              {
10053
55
                case 0x00:
10054
55
                    {
10055
                      /** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */
10056
55
#line 1077 "rx-decode.opc"
10057
55
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10058
55
#line 1077 "rx-decode.opc"
10059
55
                      int rdst AU = op[2] & 0x0f;
10060
55
                      if (trace)
10061
0
                        {
10062
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10063
0
                                 "/** 1111 1100 0100 1011 rsrc rdst stz %1, %0 */",
10064
0
                                 op[0], op[1], op[2]);
10065
0
                          printf ("  rsrc = 0x%x,", rsrc);
10066
0
                          printf ("  rdst = 0x%x\n", rdst);
10067
0
                        }
10068
55
                      SYNTAX("stz %1, %0");
10069
55
#line 1077 "rx-decode.opc"
10070
55
                      ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10071
10072
55
                    }
10073
55
                  break;
10074
55
              }
10075
55
            break;
10076
55
          case 0x4f:
10077
49
              GETBYTE ();
10078
49
              switch (op[2] & 0x00)
10079
49
              {
10080
49
                case 0x00:
10081
49
                    {
10082
                      /** 1111 1100 0100 1111 rsrc rdst stnz  %1, %0 */
10083
49
#line 1080 "rx-decode.opc"
10084
49
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10085
49
#line 1080 "rx-decode.opc"
10086
49
                      int rdst AU = op[2] & 0x0f;
10087
49
                      if (trace)
10088
0
                        {
10089
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10090
0
                                 "/** 1111 1100 0100 1111 rsrc rdst stnz  %1, %0 */",
10091
0
                                 op[0], op[1], op[2]);
10092
0
                          printf ("  rsrc = 0x%x,", rsrc);
10093
0
                          printf ("  rdst = 0x%x\n", rdst);
10094
0
                        }
10095
49
                      SYNTAX("stnz  %1, %0");
10096
49
#line 1080 "rx-decode.opc"
10097
49
                      ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
10098
10099
49
                    }
10100
49
                  break;
10101
49
              }
10102
49
            break;
10103
49
          case 0x54:
10104
20
              GETBYTE ();
10105
20
              switch (op[2] & 0x00)
10106
20
              {
10107
20
                case 0x00:
10108
507
                  op_semantics_71:
10109
507
                    {
10110
                      /** 1111 1100 0101 01sd rsrc rdst utof  %1%S1, %0 */
10111
507
#line 1137 "rx-decode.opc"
10112
507
                      int sd AU = op[1] & 0x03;
10113
507
#line 1137 "rx-decode.opc"
10114
507
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10115
507
#line 1137 "rx-decode.opc"
10116
507
                      int rdst AU = op[2] & 0x0f;
10117
507
                      if (trace)
10118
0
                        {
10119
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10120
0
                                 "/** 1111 1100 0101 01sd rsrc rdst utof  %1%S1, %0 */",
10121
0
                                 op[0], op[1], op[2]);
10122
0
                          printf ("  sd = 0x%x,", sd);
10123
0
                          printf ("  rsrc = 0x%x,", rsrc);
10124
0
                          printf ("  rdst = 0x%x\n", rdst);
10125
0
                        }
10126
507
                      SYNTAX("utof  %1%S1, %0");
10127
507
#line 1137 "rx-decode.opc"
10128
507
                      ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10129
10130
507
                    }
10131
507
                  break;
10132
20
              }
10133
507
            break;
10134
507
          case 0x55:
10135
194
              GETBYTE ();
10136
194
              switch (op[2] & 0x00)
10137
194
              {
10138
193
                case 0x00:
10139
193
                  goto op_semantics_71;
10140
0
                  break;
10141
194
              }
10142
0
            break;
10143
171
          case 0x56:
10144
171
              GETBYTE ();
10145
171
              switch (op[2] & 0x00)
10146
171
              {
10147
171
                case 0x00:
10148
171
                  goto op_semantics_71;
10149
0
                  break;
10150
171
              }
10151
0
            break;
10152
123
          case 0x57:
10153
123
              GETBYTE ();
10154
123
              switch (op[2] & 0x00)
10155
123
              {
10156
123
                case 0x00:
10157
123
                  goto op_semantics_71;
10158
0
                  break;
10159
123
              }
10160
0
            break;
10161
188
          case 0x5a:
10162
188
              GETBYTE ();
10163
188
              switch (op[2] & 0x00)
10164
188
              {
10165
188
                case 0x00:
10166
188
                    {
10167
                      /** 1111 1100 0101 1010 rsrc rdst bfmovz  %bf */
10168
188
#line 1152 "rx-decode.opc"
10169
188
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10170
188
#line 1152 "rx-decode.opc"
10171
188
                      int rdst AU = op[2] & 0x0f;
10172
188
                      if (trace)
10173
0
                        {
10174
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10175
0
                                 "/** 1111 1100 0101 1010 rsrc rdst bfmovz  %bf */",
10176
0
                                 op[0], op[1], op[2]);
10177
0
                          printf ("  rsrc = 0x%x,", rsrc);
10178
0
                          printf ("  rdst = 0x%x\n", rdst);
10179
0
                        }
10180
188
                      SYNTAX("bfmovz  %bf");
10181
188
#line 1152 "rx-decode.opc"
10182
188
                      ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10183
10184
188
                    }
10185
188
                  break;
10186
188
              }
10187
188
            break;
10188
188
          case 0x5e:
10189
135
              GETBYTE ();
10190
135
              switch (op[2] & 0x00)
10191
135
              {
10192
135
                case 0x00:
10193
135
                    {
10194
                      /** 1111 1100 0101 1110 rsrc rdst bfmov %bf */
10195
135
#line 1149 "rx-decode.opc"
10196
135
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10197
135
#line 1149 "rx-decode.opc"
10198
135
                      int rdst AU = op[2] & 0x0f;
10199
135
                      if (trace)
10200
0
                        {
10201
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10202
0
                                 "/** 1111 1100 0101 1110 rsrc rdst bfmov %bf */",
10203
0
                                 op[0], op[1], op[2]);
10204
0
                          printf ("  rsrc = 0x%x,", rsrc);
10205
0
                          printf ("  rdst = 0x%x\n", rdst);
10206
0
                        }
10207
135
                      SYNTAX("bfmov %bf");
10208
135
#line 1149 "rx-decode.opc"
10209
135
                      ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210
10211
135
                    }
10212
135
                  break;
10213
135
              }
10214
133
            break;
10215
237
          case 0x60:
10216
237
              GETBYTE ();
10217
237
              switch (op[2] & 0x00)
10218
237
              {
10219
237
                case 0x00:
10220
1.06k
                  op_semantics_72:
10221
1.06k
                    {
10222
                      /** 1111 1100 0110 00sd rdst rsrc bset  %1, %0%S0 */
10223
1.06k
#line 963 "rx-decode.opc"
10224
1.06k
                      int sd AU = op[1] & 0x03;
10225
1.06k
#line 963 "rx-decode.opc"
10226
1.06k
                      int rdst AU = (op[2] >> 4) & 0x0f;
10227
1.06k
#line 963 "rx-decode.opc"
10228
1.06k
                      int rsrc AU = op[2] & 0x0f;
10229
1.06k
                      if (trace)
10230
0
                        {
10231
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10232
0
                                 "/** 1111 1100 0110 00sd rdst rsrc bset  %1, %0%S0 */",
10233
0
                                 op[0], op[1], op[2]);
10234
0
                          printf ("  sd = 0x%x,", sd);
10235
0
                          printf ("  rdst = 0x%x,", rdst);
10236
0
                          printf ("  rsrc = 0x%x\n", rsrc);
10237
0
                        }
10238
1.06k
                      SYNTAX("bset  %1, %0%S0");
10239
1.06k
#line 963 "rx-decode.opc"
10240
1.06k
                      ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241
1.06k
                      if (sd == 3) /* bset reg,reg */
10242
358
                        BWL(LSIZE);
10243
10244
1.06k
                    }
10245
1.06k
                  break;
10246
237
              }
10247
1.06k
            break;
10248
1.06k
          case 0x61:
10249
342
              GETBYTE ();
10250
342
              switch (op[2] & 0x00)
10251
342
              {
10252
342
                case 0x00:
10253
342
                  goto op_semantics_72;
10254
0
                  break;
10255
342
              }
10256
0
            break;
10257
128
          case 0x62:
10258
128
              GETBYTE ();
10259
128
              switch (op[2] & 0x00)
10260
128
              {
10261
128
                case 0x00:
10262
128
                  goto op_semantics_72;
10263
0
                  break;
10264
128
              }
10265
0
            break;
10266
358
          case 0x63:
10267
358
              GETBYTE ();
10268
358
              switch (op[2] & 0x00)
10269
358
              {
10270
358
                case 0x00:
10271
358
                  goto op_semantics_72;
10272
0
                  break;
10273
358
              }
10274
0
            break;
10275
278
          case 0x64:
10276
278
              GETBYTE ();
10277
278
              switch (op[2] & 0x00)
10278
278
              {
10279
278
                case 0x00:
10280
632
                  op_semantics_73:
10281
632
                    {
10282
                      /** 1111 1100 0110 01sd rdst rsrc bclr  %1, %0%S0 */
10283
632
#line 975 "rx-decode.opc"
10284
632
                      int sd AU = op[1] & 0x03;
10285
632
#line 975 "rx-decode.opc"
10286
632
                      int rdst AU = (op[2] >> 4) & 0x0f;
10287
632
#line 975 "rx-decode.opc"
10288
632
                      int rsrc AU = op[2] & 0x0f;
10289
632
                      if (trace)
10290
0
                        {
10291
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10292
0
                                 "/** 1111 1100 0110 01sd rdst rsrc bclr  %1, %0%S0 */",
10293
0
                                 op[0], op[1], op[2]);
10294
0
                          printf ("  sd = 0x%x,", sd);
10295
0
                          printf ("  rdst = 0x%x,", rdst);
10296
0
                          printf ("  rsrc = 0x%x\n", rsrc);
10297
0
                        }
10298
632
                      SYNTAX("bclr  %1, %0%S0");
10299
632
#line 975 "rx-decode.opc"
10300
632
                      ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301
632
                      if (sd == 3) /* bset reg,reg */
10302
64
                        BWL(LSIZE);
10303
10304
632
                    }
10305
632
                  break;
10306
278
              }
10307
632
            break;
10308
632
          case 0x65:
10309
114
              GETBYTE ();
10310
114
              switch (op[2] & 0x00)
10311
114
              {
10312
114
                case 0x00:
10313
114
                  goto op_semantics_73;
10314
0
                  break;
10315
114
              }
10316
0
            break;
10317
176
          case 0x66:
10318
176
              GETBYTE ();
10319
176
              switch (op[2] & 0x00)
10320
176
              {
10321
176
                case 0x00:
10322
176
                  goto op_semantics_73;
10323
0
                  break;
10324
176
              }
10325
0
            break;
10326
64
          case 0x67:
10327
64
              GETBYTE ();
10328
64
              switch (op[2] & 0x00)
10329
64
              {
10330
64
                case 0x00:
10331
64
                  goto op_semantics_73;
10332
0
                  break;
10333
64
              }
10334
0
            break;
10335
138
          case 0x68:
10336
138
              GETBYTE ();
10337
138
              switch (op[2] & 0x00)
10338
138
              {
10339
138
                case 0x00:
10340
472
                  op_semantics_74:
10341
472
                    {
10342
                      /** 1111 1100 0110 10sd rdst rsrc btst  %2, %1%S1 */
10343
472
#line 987 "rx-decode.opc"
10344
472
                      int sd AU = op[1] & 0x03;
10345
472
#line 987 "rx-decode.opc"
10346
472
                      int rdst AU = (op[2] >> 4) & 0x0f;
10347
472
#line 987 "rx-decode.opc"
10348
472
                      int rsrc AU = op[2] & 0x0f;
10349
472
                      if (trace)
10350
0
                        {
10351
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10352
0
                                 "/** 1111 1100 0110 10sd rdst rsrc btst  %2, %1%S1 */",
10353
0
                                 op[0], op[1], op[2]);
10354
0
                          printf ("  sd = 0x%x,", sd);
10355
0
                          printf ("  rdst = 0x%x,", rdst);
10356
0
                          printf ("  rsrc = 0x%x\n", rsrc);
10357
0
                        }
10358
472
                      SYNTAX("btst  %2, %1%S1");
10359
472
#line 987 "rx-decode.opc"
10360
472
                      ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361
472
                      if (sd == 3) /* bset reg,reg */
10362
111
                        BWL(LSIZE);
10363
10364
472
                    }
10365
472
                  break;
10366
138
              }
10367
472
            break;
10368
472
          case 0x69:
10369
119
              GETBYTE ();
10370
119
              switch (op[2] & 0x00)
10371
119
              {
10372
119
                case 0x00:
10373
119
                  goto op_semantics_74;
10374
0
                  break;
10375
119
              }
10376
0
            break;
10377
104
          case 0x6a:
10378
104
              GETBYTE ();
10379
104
              switch (op[2] & 0x00)
10380
104
              {
10381
104
                case 0x00:
10382
104
                  goto op_semantics_74;
10383
0
                  break;
10384
104
              }
10385
0
            break;
10386
111
          case 0x6b:
10387
111
              GETBYTE ();
10388
111
              switch (op[2] & 0x00)
10389
111
              {
10390
111
                case 0x00:
10391
111
                  goto op_semantics_74;
10392
0
                  break;
10393
111
              }
10394
0
            break;
10395
63
          case 0x6c:
10396
63
              GETBYTE ();
10397
63
              switch (op[2] & 0x00)
10398
63
              {
10399
63
                case 0x00:
10400
393
                  op_semantics_75:
10401
393
                    {
10402
                      /** 1111 1100 0110 11sd rdst rsrc bnot  %1, %0%S0 */
10403
393
#line 999 "rx-decode.opc"
10404
393
                      int sd AU = op[1] & 0x03;
10405
393
#line 999 "rx-decode.opc"
10406
393
                      int rdst AU = (op[2] >> 4) & 0x0f;
10407
393
#line 999 "rx-decode.opc"
10408
393
                      int rsrc AU = op[2] & 0x0f;
10409
393
                      if (trace)
10410
0
                        {
10411
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10412
0
                                 "/** 1111 1100 0110 11sd rdst rsrc bnot  %1, %0%S0 */",
10413
0
                                 op[0], op[1], op[2]);
10414
0
                          printf ("  sd = 0x%x,", sd);
10415
0
                          printf ("  rdst = 0x%x,", rdst);
10416
0
                          printf ("  rsrc = 0x%x\n", rsrc);
10417
0
                        }
10418
393
                      SYNTAX("bnot  %1, %0%S0");
10419
393
#line 999 "rx-decode.opc"
10420
393
                      ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421
393
                      if (sd == 3) /* bset reg,reg */
10422
64
                        BWL(LSIZE);
10423
10424
393
                    }
10425
393
                  break;
10426
63
              }
10427
393
            break;
10428
393
          case 0x6d:
10429
204
              GETBYTE ();
10430
204
              switch (op[2] & 0x00)
10431
204
              {
10432
204
                case 0x00:
10433
204
                  goto op_semantics_75;
10434
0
                  break;
10435
204
              }
10436
0
            break;
10437
62
          case 0x6e:
10438
62
              GETBYTE ();
10439
62
              switch (op[2] & 0x00)
10440
62
              {
10441
62
                case 0x00:
10442
62
                  goto op_semantics_75;
10443
0
                  break;
10444
62
              }
10445
0
            break;
10446
64
          case 0x6f:
10447
64
              GETBYTE ();
10448
64
              switch (op[2] & 0x00)
10449
64
              {
10450
64
                case 0x00:
10451
64
                  goto op_semantics_75;
10452
0
                  break;
10453
64
              }
10454
0
            break;
10455
437
          case 0x78:
10456
437
              GETBYTE ();
10457
437
              switch (op[2] & 0x0f)
10458
437
              {
10459
10
                case 0x08:
10460
28
                  op_semantics_76:
10461
28
                    {
10462
                      /** 1111 1100 0111 10sz rdst 1000 dmov.d  %1, %0 */
10463
28
#line 1185 "rx-decode.opc"
10464
28
                      int sz AU = op[1] & 0x03;
10465
28
#line 1185 "rx-decode.opc"
10466
28
                      int rdst AU = (op[2] >> 4) & 0x0f;
10467
28
                      if (trace)
10468
0
                        {
10469
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10470
0
                                 "/** 1111 1100 0111 10sz rdst 1000 dmov.d  %1, %0 */",
10471
0
                                 op[0], op[1], op[2]);
10472
0
                          printf ("  sz = 0x%x,", sz);
10473
0
                          printf ("  rdst = 0x%x\n", rdst);
10474
0
                        }
10475
28
                      SYNTAX("dmov.d  %1, %0");
10476
28
#line 1185 "rx-decode.opc"
10477
28
                      int rsrc;
10478
28
                      rx_disp(0, sz, rdst, RX_Double, ld);
10479
28
                      rsrc = GETBYTE();
10480
28
                      if (rsrc & 0x0f)
10481
28
                        UNSUPPORTED();
10482
0
                      else {
10483
0
                        ID(dmov); SDR(rsrc >> 4); F_____;
10484
0
                      }
10485
10486
28
                    }
10487
28
                  break;
10488
422
                default: UNSUPPORTED(); break;
10489
437
              }
10490
450
            break;
10491
450
          case 0x79:
10492
294
              GETBYTE ();
10493
294
              switch (op[2] & 0x0f)
10494
294
              {
10495
17
                case 0x08:
10496
17
                  goto op_semantics_76;
10497
0
                  break;
10498
277
                default: UNSUPPORTED(); break;
10499
294
              }
10500
277
            break;
10501
277
          case 0x7a:
10502
200
              GETBYTE ();
10503
200
              switch (op[2] & 0x0f)
10504
200
              {
10505
1
                case 0x08:
10506
1
                  goto op_semantics_76;
10507
0
                  break;
10508
199
                default: UNSUPPORTED(); break;
10509
200
              }
10510
199
            break;
10511
1.53k
          case 0x80:
10512
1.53k
              GETBYTE ();
10513
1.53k
              switch (op[2] & 0x00)
10514
1.53k
              {
10515
1.53k
                case 0x00:
10516
2.25k
                  op_semantics_77:
10517
2.25k
                    {
10518
                      /** 1111 1100 1000 00sd rsrc rdst fsub  %1%S1, %0 */
10519
2.25k
#line 930 "rx-decode.opc"
10520
2.25k
                      int sd AU = op[1] & 0x03;
10521
2.25k
#line 930 "rx-decode.opc"
10522
2.25k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10523
2.25k
#line 930 "rx-decode.opc"
10524
2.25k
                      int rdst AU = op[2] & 0x0f;
10525
2.25k
                      if (trace)
10526
0
                        {
10527
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10528
0
                                 "/** 1111 1100 1000 00sd rsrc rdst fsub  %1%S1, %0 */",
10529
0
                                 op[0], op[1], op[2]);
10530
0
                          printf ("  sd = 0x%x,", sd);
10531
0
                          printf ("  rsrc = 0x%x,", rsrc);
10532
0
                          printf ("  rdst = 0x%x\n", rdst);
10533
0
                        }
10534
2.25k
                      SYNTAX("fsub  %1%S1, %0");
10535
2.25k
#line 930 "rx-decode.opc"
10536
2.25k
                      ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10537
10538
2.25k
                    }
10539
2.25k
                  break;
10540
1.53k
              }
10541
2.25k
            break;
10542
2.25k
          case 0x81:
10543
54
              GETBYTE ();
10544
54
              switch (op[2] & 0x00)
10545
54
              {
10546
53
                case 0x00:
10547
53
                  goto op_semantics_77;
10548
0
                  break;
10549
54
              }
10550
0
            break;
10551
88
          case 0x82:
10552
88
              GETBYTE ();
10553
88
              switch (op[2] & 0x00)
10554
88
              {
10555
88
                case 0x00:
10556
88
                  goto op_semantics_77;
10557
0
                  break;
10558
88
              }
10559
0
            break;
10560
578
          case 0x83:
10561
578
              GETBYTE ();
10562
578
              switch (op[2] & 0x00)
10563
578
              {
10564
578
                case 0x00:
10565
578
                  goto op_semantics_77;
10566
0
                  break;
10567
578
              }
10568
0
            break;
10569
59
          case 0x84:
10570
59
              GETBYTE ();
10571
59
              switch (op[2] & 0x00)
10572
59
              {
10573
59
                case 0x00:
10574
1.07k
                  op_semantics_78:
10575
1.07k
                    {
10576
                      /** 1111 1100 1000 01sd rsrc rdst fcmp  %1%S1, %0 */
10577
1.07k
#line 924 "rx-decode.opc"
10578
1.07k
                      int sd AU = op[1] & 0x03;
10579
1.07k
#line 924 "rx-decode.opc"
10580
1.07k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10581
1.07k
#line 924 "rx-decode.opc"
10582
1.07k
                      int rdst AU = op[2] & 0x0f;
10583
1.07k
                      if (trace)
10584
0
                        {
10585
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10586
0
                                 "/** 1111 1100 1000 01sd rsrc rdst fcmp  %1%S1, %0 */",
10587
0
                                 op[0], op[1], op[2]);
10588
0
                          printf ("  sd = 0x%x,", sd);
10589
0
                          printf ("  rsrc = 0x%x,", rsrc);
10590
0
                          printf ("  rdst = 0x%x\n", rdst);
10591
0
                        }
10592
1.07k
                      SYNTAX("fcmp  %1%S1, %0");
10593
1.07k
#line 924 "rx-decode.opc"
10594
1.07k
                      ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
10595
10596
1.07k
                    }
10597
1.07k
                  break;
10598
59
              }
10599
1.07k
            break;
10600
1.07k
          case 0x85:
10601
63
              GETBYTE ();
10602
63
              switch (op[2] & 0x00)
10603
63
              {
10604
49
                case 0x00:
10605
49
                  goto op_semantics_78;
10606
0
                  break;
10607
63
              }
10608
0
            break;
10609
661
          case 0x86:
10610
661
              GETBYTE ();
10611
661
              switch (op[2] & 0x00)
10612
661
              {
10613
660
                case 0x00:
10614
660
                  goto op_semantics_78;
10615
0
                  break;
10616
661
              }
10617
0
            break;
10618
303
          case 0x87:
10619
303
              GETBYTE ();
10620
303
              switch (op[2] & 0x00)
10621
303
              {
10622
303
                case 0x00:
10623
303
                  goto op_semantics_78;
10624
0
                  break;
10625
303
              }
10626
0
            break;
10627
143
          case 0x88:
10628
143
              GETBYTE ();
10629
143
              switch (op[2] & 0x00)
10630
143
              {
10631
143
                case 0x00:
10632
1.35k
                  op_semantics_79:
10633
1.35k
                    {
10634
                      /** 1111 1100 1000 10sd rsrc rdst fadd  %1%S1, %0 */
10635
1.35k
#line 918 "rx-decode.opc"
10636
1.35k
                      int sd AU = op[1] & 0x03;
10637
1.35k
#line 918 "rx-decode.opc"
10638
1.35k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10639
1.35k
#line 918 "rx-decode.opc"
10640
1.35k
                      int rdst AU = op[2] & 0x0f;
10641
1.35k
                      if (trace)
10642
0
                        {
10643
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10644
0
                                 "/** 1111 1100 1000 10sd rsrc rdst fadd  %1%S1, %0 */",
10645
0
                                 op[0], op[1], op[2]);
10646
0
                          printf ("  sd = 0x%x,", sd);
10647
0
                          printf ("  rsrc = 0x%x,", rsrc);
10648
0
                          printf ("  rdst = 0x%x\n", rdst);
10649
0
                        }
10650
1.35k
                      SYNTAX("fadd  %1%S1, %0");
10651
1.35k
#line 918 "rx-decode.opc"
10652
1.35k
                      ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10653
10654
1.35k
                    }
10655
1.35k
                  break;
10656
143
              }
10657
1.35k
            break;
10658
1.35k
          case 0x89:
10659
1.13k
              GETBYTE ();
10660
1.13k
              switch (op[2] & 0x00)
10661
1.13k
              {
10662
1.11k
                case 0x00:
10663
1.11k
                  goto op_semantics_79;
10664
0
                  break;
10665
1.13k
              }
10666
0
            break;
10667
45
          case 0x8a:
10668
45
              GETBYTE ();
10669
45
              switch (op[2] & 0x00)
10670
45
              {
10671
45
                case 0x00:
10672
45
                  goto op_semantics_79;
10673
0
                  break;
10674
45
              }
10675
0
            break;
10676
55
          case 0x8b:
10677
55
              GETBYTE ();
10678
55
              switch (op[2] & 0x00)
10679
55
              {
10680
55
                case 0x00:
10681
55
                  goto op_semantics_79;
10682
0
                  break;
10683
55
              }
10684
0
            break;
10685
71
          case 0x8c:
10686
71
              GETBYTE ();
10687
71
              switch (op[2] & 0x00)
10688
71
              {
10689
71
                case 0x00:
10690
603
                  op_semantics_80:
10691
603
                    {
10692
                      /** 1111 1100 1000 11sd rsrc rdst fmul  %1%S1, %0 */
10693
603
#line 939 "rx-decode.opc"
10694
603
                      int sd AU = op[1] & 0x03;
10695
603
#line 939 "rx-decode.opc"
10696
603
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10697
603
#line 939 "rx-decode.opc"
10698
603
                      int rdst AU = op[2] & 0x0f;
10699
603
                      if (trace)
10700
0
                        {
10701
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10702
0
                                 "/** 1111 1100 1000 11sd rsrc rdst fmul  %1%S1, %0 */",
10703
0
                                 op[0], op[1], op[2]);
10704
0
                          printf ("  sd = 0x%x,", sd);
10705
0
                          printf ("  rsrc = 0x%x,", rsrc);
10706
0
                          printf ("  rdst = 0x%x\n", rdst);
10707
0
                        }
10708
603
                      SYNTAX("fmul  %1%S1, %0");
10709
603
#line 939 "rx-decode.opc"
10710
603
                      ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10711
10712
603
                    }
10713
603
                  break;
10714
71
              }
10715
603
            break;
10716
603
          case 0x8d:
10717
164
              GETBYTE ();
10718
164
              switch (op[2] & 0x00)
10719
164
              {
10720
164
                case 0x00:
10721
164
                  goto op_semantics_80;
10722
0
                  break;
10723
164
              }
10724
0
            break;
10725
264
          case 0x8e:
10726
264
              GETBYTE ();
10727
264
              switch (op[2] & 0x00)
10728
264
              {
10729
264
                case 0x00:
10730
264
                  goto op_semantics_80;
10731
0
                  break;
10732
264
              }
10733
0
            break;
10734
104
          case 0x8f:
10735
104
              GETBYTE ();
10736
104
              switch (op[2] & 0x00)
10737
104
              {
10738
104
                case 0x00:
10739
104
                  goto op_semantics_80;
10740
0
                  break;
10741
104
              }
10742
0
            break;
10743
136
          case 0x90:
10744
136
              GETBYTE ();
10745
136
              switch (op[2] & 0x00)
10746
136
              {
10747
136
                case 0x00:
10748
568
                  op_semantics_81:
10749
568
                    {
10750
                      /** 1111 1100 1001 00sd rsrc rdst fdiv  %1%S1, %0 */
10751
568
#line 945 "rx-decode.opc"
10752
568
                      int sd AU = op[1] & 0x03;
10753
568
#line 945 "rx-decode.opc"
10754
568
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10755
568
#line 945 "rx-decode.opc"
10756
568
                      int rdst AU = op[2] & 0x0f;
10757
568
                      if (trace)
10758
0
                        {
10759
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10760
0
                                 "/** 1111 1100 1001 00sd rsrc rdst fdiv  %1%S1, %0 */",
10761
0
                                 op[0], op[1], op[2]);
10762
0
                          printf ("  sd = 0x%x,", sd);
10763
0
                          printf ("  rsrc = 0x%x,", rsrc);
10764
0
                          printf ("  rdst = 0x%x\n", rdst);
10765
0
                        }
10766
568
                      SYNTAX("fdiv  %1%S1, %0");
10767
568
#line 945 "rx-decode.opc"
10768
568
                      ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10769
10770
568
                    }
10771
568
                  break;
10772
136
              }
10773
568
            break;
10774
568
          case 0x91:
10775
205
              GETBYTE ();
10776
205
              switch (op[2] & 0x00)
10777
205
              {
10778
205
                case 0x00:
10779
205
                  goto op_semantics_81;
10780
0
                  break;
10781
205
              }
10782
0
            break;
10783
193
          case 0x92:
10784
193
              GETBYTE ();
10785
193
              switch (op[2] & 0x00)
10786
193
              {
10787
193
                case 0x00:
10788
193
                  goto op_semantics_81;
10789
0
                  break;
10790
193
              }
10791
0
            break;
10792
34
          case 0x93:
10793
34
              GETBYTE ();
10794
34
              switch (op[2] & 0x00)
10795
34
              {
10796
34
                case 0x00:
10797
34
                  goto op_semantics_81;
10798
0
                  break;
10799
34
              }
10800
0
            break;
10801
279
          case 0x94:
10802
279
              GETBYTE ();
10803
279
              switch (op[2] & 0x00)
10804
279
              {
10805
279
                case 0x00:
10806
525
                  op_semantics_82:
10807
525
                    {
10808
                      /** 1111 1100 1001 01sd rsrc rdst ftoi  %1%S1, %0 */
10809
525
#line 933 "rx-decode.opc"
10810
525
                      int sd AU = op[1] & 0x03;
10811
525
#line 933 "rx-decode.opc"
10812
525
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10813
525
#line 933 "rx-decode.opc"
10814
525
                      int rdst AU = op[2] & 0x0f;
10815
525
                      if (trace)
10816
0
                        {
10817
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10818
0
                                 "/** 1111 1100 1001 01sd rsrc rdst ftoi  %1%S1, %0 */",
10819
0
                                 op[0], op[1], op[2]);
10820
0
                          printf ("  sd = 0x%x,", sd);
10821
0
                          printf ("  rsrc = 0x%x,", rsrc);
10822
0
                          printf ("  rdst = 0x%x\n", rdst);
10823
0
                        }
10824
525
                      SYNTAX("ftoi  %1%S1, %0");
10825
525
#line 933 "rx-decode.opc"
10826
525
                      ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10827
10828
525
                    }
10829
525
                  break;
10830
279
              }
10831
525
            break;
10832
525
          case 0x95:
10833
55
              GETBYTE ();
10834
55
              switch (op[2] & 0x00)
10835
55
              {
10836
55
                case 0x00:
10837
55
                  goto op_semantics_82;
10838
0
                  break;
10839
55
              }
10840
0
            break;
10841
119
          case 0x96:
10842
119
              GETBYTE ();
10843
119
              switch (op[2] & 0x00)
10844
119
              {
10845
119
                case 0x00:
10846
119
                  goto op_semantics_82;
10847
0
                  break;
10848
119
              }
10849
0
            break;
10850
72
          case 0x97:
10851
72
              GETBYTE ();
10852
72
              switch (op[2] & 0x00)
10853
72
              {
10854
72
                case 0x00:
10855
72
                  goto op_semantics_82;
10856
0
                  break;
10857
72
              }
10858
0
            break;
10859
221
          case 0x98:
10860
221
              GETBYTE ();
10861
221
              switch (op[2] & 0x00)
10862
221
              {
10863
211
                case 0x00:
10864
585
                  op_semantics_83:
10865
585
                    {
10866
                      /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
10867
585
#line 948 "rx-decode.opc"
10868
585
                      int sd AU = op[1] & 0x03;
10869
585
#line 948 "rx-decode.opc"
10870
585
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10871
585
#line 948 "rx-decode.opc"
10872
585
                      int rdst AU = op[2] & 0x0f;
10873
585
                      if (trace)
10874
0
                        {
10875
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10876
0
                                 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
10877
0
                                 op[0], op[1], op[2]);
10878
0
                          printf ("  sd = 0x%x,", sd);
10879
0
                          printf ("  rsrc = 0x%x,", rsrc);
10880
0
                          printf ("  rdst = 0x%x\n", rdst);
10881
0
                        }
10882
585
                      SYNTAX("round %1%S1, %0");
10883
585
#line 948 "rx-decode.opc"
10884
585
                      ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10885
10886
585
                    }
10887
585
                  break;
10888
221
              }
10889
585
            break;
10890
585
          case 0x99:
10891
81
              GETBYTE ();
10892
81
              switch (op[2] & 0x00)
10893
81
              {
10894
81
                case 0x00:
10895
81
                  goto op_semantics_83;
10896
0
                  break;
10897
81
              }
10898
0
            break;
10899
140
          case 0x9a:
10900
140
              GETBYTE ();
10901
140
              switch (op[2] & 0x00)
10902
140
              {
10903
140
                case 0x00:
10904
140
                  goto op_semantics_83;
10905
0
                  break;
10906
140
              }
10907
0
            break;
10908
153
          case 0x9b:
10909
153
              GETBYTE ();
10910
153
              switch (op[2] & 0x00)
10911
153
              {
10912
153
                case 0x00:
10913
153
                  goto op_semantics_83;
10914
0
                  break;
10915
153
              }
10916
0
            break;
10917
473
          case 0xa0:
10918
473
              GETBYTE ();
10919
473
              switch (op[2] & 0x00)
10920
473
              {
10921
473
                case 0x00:
10922
783
                  op_semantics_84:
10923
783
                    {
10924
                      /** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */
10925
783
#line 1131 "rx-decode.opc"
10926
783
                      int sd AU = op[1] & 0x03;
10927
783
#line 1131 "rx-decode.opc"
10928
783
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10929
783
#line 1131 "rx-decode.opc"
10930
783
                      int rdst AU = op[2] & 0x0f;
10931
783
                      if (trace)
10932
0
                        {
10933
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10934
0
                                 "/** 1111 1100 1010 00sd rsrc rdst fsqrt %1%S1, %0 */",
10935
0
                                 op[0], op[1], op[2]);
10936
0
                          printf ("  sd = 0x%x,", sd);
10937
0
                          printf ("  rsrc = 0x%x,", rsrc);
10938
0
                          printf ("  rdst = 0x%x\n", rdst);
10939
0
                        }
10940
783
                      SYNTAX("fsqrt %1%S1, %0");
10941
783
#line 1131 "rx-decode.opc"
10942
783
                      ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10943
10944
783
                    }
10945
783
                  break;
10946
473
              }
10947
783
            break;
10948
783
          case 0xa1:
10949
235
              GETBYTE ();
10950
235
              switch (op[2] & 0x00)
10951
235
              {
10952
202
                case 0x00:
10953
202
                  goto op_semantics_84;
10954
0
                  break;
10955
235
              }
10956
0
            break;
10957
46
          case 0xa2:
10958
46
              GETBYTE ();
10959
46
              switch (op[2] & 0x00)
10960
46
              {
10961
43
                case 0x00:
10962
43
                  goto op_semantics_84;
10963
0
                  break;
10964
46
              }
10965
0
            break;
10966
65
          case 0xa3:
10967
65
              GETBYTE ();
10968
65
              switch (op[2] & 0x00)
10969
65
              {
10970
65
                case 0x00:
10971
65
                  goto op_semantics_84;
10972
0
                  break;
10973
65
              }
10974
0
            break;
10975
361
          case 0xa4:
10976
361
              GETBYTE ();
10977
361
              switch (op[2] & 0x00)
10978
361
              {
10979
361
                case 0x00:
10980
603
                  op_semantics_85:
10981
603
                    {
10982
                      /** 1111 1100 1010 01sd rsrc rdst ftou  %1%S1, %0 */
10983
603
#line 1134 "rx-decode.opc"
10984
603
                      int sd AU = op[1] & 0x03;
10985
603
#line 1134 "rx-decode.opc"
10986
603
                      int rsrc AU = (op[2] >> 4) & 0x0f;
10987
603
#line 1134 "rx-decode.opc"
10988
603
                      int rdst AU = op[2] & 0x0f;
10989
603
                      if (trace)
10990
0
                        {
10991
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10992
0
                                 "/** 1111 1100 1010 01sd rsrc rdst ftou  %1%S1, %0 */",
10993
0
                                 op[0], op[1], op[2]);
10994
0
                          printf ("  sd = 0x%x,", sd);
10995
0
                          printf ("  rsrc = 0x%x,", rsrc);
10996
0
                          printf ("  rdst = 0x%x\n", rdst);
10997
0
                        }
10998
603
                      SYNTAX("ftou  %1%S1, %0");
10999
603
#line 1134 "rx-decode.opc"
11000
603
                      ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11001
11002
603
                    }
11003
603
                  break;
11004
361
              }
11005
603
            break;
11006
603
          case 0xa5:
11007
54
              GETBYTE ();
11008
54
              switch (op[2] & 0x00)
11009
54
              {
11010
54
                case 0x00:
11011
54
                  goto op_semantics_85;
11012
0
                  break;
11013
54
              }
11014
0
            break;
11015
160
          case 0xa6:
11016
160
              GETBYTE ();
11017
160
              switch (op[2] & 0x00)
11018
160
              {
11019
160
                case 0x00:
11020
160
                  goto op_semantics_85;
11021
0
                  break;
11022
160
              }
11023
0
            break;
11024
28
          case 0xa7:
11025
28
              GETBYTE ();
11026
28
              switch (op[2] & 0x00)
11027
28
              {
11028
28
                case 0x00:
11029
28
                  goto op_semantics_85;
11030
0
                  break;
11031
28
              }
11032
0
            break;
11033
2.42k
          case 0xc8:
11034
2.42k
              GETBYTE ();
11035
2.42k
              switch (op[2] & 0x0f)
11036
2.42k
              {
11037
2.09k
                case 0x08:
11038
2.20k
                  op_semantics_86:
11039
2.20k
                    {
11040
                      /** 1111 1100 1100 10sz rsrc 1000 dmov.d  %1, %0 */
11041
2.20k
#line 1198 "rx-decode.opc"
11042
2.20k
                      int sz AU = op[1] & 0x03;
11043
2.20k
#line 1198 "rx-decode.opc"
11044
2.20k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
11045
2.20k
                      if (trace)
11046
0
                        {
11047
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11048
0
                                 "/** 1111 1100 1100 10sz rsrc 1000 dmov.d  %1, %0 */",
11049
0
                                 op[0], op[1], op[2]);
11050
0
                          printf ("  sz = 0x%x,", sz);
11051
0
                          printf ("  rsrc = 0x%x\n", rsrc);
11052
0
                        }
11053
2.20k
                      SYNTAX("dmov.d  %1, %0");
11054
2.20k
#line 1198 "rx-decode.opc"
11055
2.20k
                      int rdst;
11056
2.20k
                      rx_disp(1, sz, rsrc, RX_Double, ld);
11057
2.20k
                      rdst = GETBYTE();
11058
2.20k
                      if (rdst & 0x0f)
11059
2.19k
                        UNSUPPORTED();
11060
4
                      else {
11061
4
                        ID(dmov); DDR(rdst >> 4); F_____;
11062
4
                      }
11063
11064
2.20k
                    }
11065
2.20k
                  break;
11066
326
                default: UNSUPPORTED(); break;
11067
2.42k
              }
11068
2.52k
            break;
11069
2.52k
          case 0xc9:
11070
80
              GETBYTE ();
11071
80
              switch (op[2] & 0x0f)
11072
80
              {
11073
5
                case 0x08:
11074
5
                  goto op_semantics_86;
11075
0
                  break;
11076
75
                default: UNSUPPORTED(); break;
11077
80
              }
11078
75
            break;
11079
151
          case 0xca:
11080
151
              GETBYTE ();
11081
151
              switch (op[2] & 0x0f)
11082
151
              {
11083
100
                case 0x08:
11084
100
                  goto op_semantics_86;
11085
0
                  break;
11086
51
                default: UNSUPPORTED(); break;
11087
151
              }
11088
51
            break;
11089
558
          case 0xd0:
11090
558
              GETBYTE ();
11091
558
              switch (op[2] & 0x00)
11092
558
              {
11093
558
                case 0x00:
11094
2.76k
                  op_semantics_87:
11095
2.76k
                    {
11096
                      /** 1111 1100 1101 sz sd rdst cond  sc%1%s  %0 */
11097
2.76k
#line 1065 "rx-decode.opc"
11098
2.76k
                      int sz AU = (op[1] >> 2) & 0x03;
11099
2.76k
#line 1065 "rx-decode.opc"
11100
2.76k
                      int sd AU = op[1] & 0x03;
11101
2.76k
#line 1065 "rx-decode.opc"
11102
2.76k
                      int rdst AU = (op[2] >> 4) & 0x0f;
11103
2.76k
#line 1065 "rx-decode.opc"
11104
2.76k
                      int cond AU = op[2] & 0x0f;
11105
2.76k
                      if (trace)
11106
0
                        {
11107
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11108
0
                                 "/** 1111 1100 1101 sz sd rdst cond  sc%1%s  %0 */",
11109
0
                                 op[0], op[1], op[2]);
11110
0
                          printf ("  sz = 0x%x,", sz);
11111
0
                          printf ("  sd = 0x%x,", sd);
11112
0
                          printf ("  rdst = 0x%x,", rdst);
11113
0
                          printf ("  cond = 0x%x\n", cond);
11114
0
                        }
11115
2.76k
                      SYNTAX("sc%1%s  %0");
11116
2.76k
#line 1065 "rx-decode.opc"
11117
2.76k
                      ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118
11119
                    /*----------------------------------------------------------------------*/
11120
                    /* RXv2 enhanced              */
11121
11122
2.76k
                    }
11123
2.76k
                  break;
11124
558
              }
11125
2.76k
            break;
11126
2.76k
          case 0xd1:
11127
135
              GETBYTE ();
11128
135
              switch (op[2] & 0x00)
11129
135
              {
11130
135
                case 0x00:
11131
135
                  goto op_semantics_87;
11132
0
                  break;
11133
135
              }
11134
0
            break;
11135
514
          case 0xd2:
11136
514
              GETBYTE ();
11137
514
              switch (op[2] & 0x00)
11138
514
              {
11139
514
                case 0x00:
11140
514
                  goto op_semantics_87;
11141
0
                  break;
11142
514
              }
11143
0
            break;
11144
233
          case 0xd3:
11145
233
              GETBYTE ();
11146
233
              switch (op[2] & 0x00)
11147
233
              {
11148
233
                case 0x00:
11149
233
                  goto op_semantics_87;
11150
0
                  break;
11151
233
              }
11152
0
            break;
11153
150
          case 0xd4:
11154
150
              GETBYTE ();
11155
150
              switch (op[2] & 0x00)
11156
150
              {
11157
150
                case 0x00:
11158
150
                  goto op_semantics_87;
11159
0
                  break;
11160
150
              }
11161
0
            break;
11162
33
          case 0xd5:
11163
33
              GETBYTE ();
11164
33
              switch (op[2] & 0x00)
11165
33
              {
11166
33
                case 0x00:
11167
33
                  goto op_semantics_87;
11168
0
                  break;
11169
33
              }
11170
0
            break;
11171
56
          case 0xd6:
11172
56
              GETBYTE ();
11173
56
              switch (op[2] & 0x00)
11174
56
              {
11175
56
                case 0x00:
11176
56
                  goto op_semantics_87;
11177
0
                  break;
11178
56
              }
11179
0
            break;
11180
278
          case 0xd7:
11181
278
              GETBYTE ();
11182
278
              switch (op[2] & 0x00)
11183
278
              {
11184
278
                case 0x00:
11185
278
                  goto op_semantics_87;
11186
0
                  break;
11187
278
              }
11188
0
            break;
11189
410
          case 0xd8:
11190
410
              GETBYTE ();
11191
410
              switch (op[2] & 0x00)
11192
410
              {
11193
410
                case 0x00:
11194
410
                  goto op_semantics_87;
11195
0
                  break;
11196
410
              }
11197
0
            break;
11198
195
          case 0xd9:
11199
195
              GETBYTE ();
11200
195
              switch (op[2] & 0x00)
11201
195
              {
11202
195
                case 0x00:
11203
195
                  goto op_semantics_87;
11204
0
                  break;
11205
195
              }
11206
0
            break;
11207
164
          case 0xda:
11208
164
              GETBYTE ();
11209
164
              switch (op[2] & 0x00)
11210
164
              {
11211
164
                case 0x00:
11212
164
                  goto op_semantics_87;
11213
0
                  break;
11214
164
              }
11215
0
            break;
11216
34
          case 0xdb:
11217
34
              GETBYTE ();
11218
34
              switch (op[2] & 0x00)
11219
34
              {
11220
34
                case 0x00:
11221
34
                  goto op_semantics_87;
11222
0
                  break;
11223
34
              }
11224
0
            break;
11225
113
          case 0xe0:
11226
113
              GETBYTE ();
11227
113
              switch (op[2] & 0x0f)
11228
113
              {
11229
42
                case 0x00:
11230
42
                case 0x01:
11231
42
                case 0x02:
11232
43
                case 0x03:
11233
44
                case 0x04:
11234
44
                case 0x05:
11235
44
                case 0x06:
11236
44
                case 0x07:
11237
44
                case 0x08:
11238
44
                case 0x09:
11239
44
                case 0x0a:
11240
44
                case 0x0b:
11241
44
                case 0x0c:
11242
67
                case 0x0d:
11243
67
                case 0x0e:
11244
38.8k
                  op_semantics_88:
11245
38.8k
                    {
11246
                      /** 1111 1100 111bit sd rdst cond bm%2  #%1, %0%S0 */
11247
38.8k
#line 1008 "rx-decode.opc"
11248
38.8k
                      int bit AU = (op[1] >> 2) & 0x07;
11249
38.8k
#line 1008 "rx-decode.opc"
11250
38.8k
                      int sd AU = op[1] & 0x03;
11251
38.8k
#line 1008 "rx-decode.opc"
11252
38.8k
                      int rdst AU = (op[2] >> 4) & 0x0f;
11253
38.8k
#line 1008 "rx-decode.opc"
11254
38.8k
                      int cond AU = op[2] & 0x0f;
11255
38.8k
                      if (trace)
11256
0
                        {
11257
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11258
0
                                 "/** 1111 1100 111bit sd rdst cond bm%2  #%1, %0%S0 */",
11259
0
                                 op[0], op[1], op[2]);
11260
0
                          printf ("  bit = 0x%x,", bit);
11261
0
                          printf ("  sd = 0x%x,", sd);
11262
0
                          printf ("  rdst = 0x%x,", rdst);
11263
0
                          printf ("  cond = 0x%x\n", cond);
11264
0
                        }
11265
38.8k
                      SYNTAX("bm%2  #%1, %0%S0");
11266
38.8k
#line 1008 "rx-decode.opc"
11267
38.8k
                      ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268
11269
38.8k
                    }
11270
38.8k
                  break;
11271
46
                case 0x0f:
11272
21.8k
                  op_semantics_89:
11273
21.8k
                    {
11274
                      /** 1111 1100 111bit sd rdst 1111 bnot  #%1, %0%S0 */
11275
21.8k
#line 996 "rx-decode.opc"
11276
21.8k
                      int bit AU = (op[1] >> 2) & 0x07;
11277
21.8k
#line 996 "rx-decode.opc"
11278
21.8k
                      int sd AU = op[1] & 0x03;
11279
21.8k
#line 996 "rx-decode.opc"
11280
21.8k
                      int rdst AU = (op[2] >> 4) & 0x0f;
11281
21.8k
                      if (trace)
11282
0
                        {
11283
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11284
0
                                 "/** 1111 1100 111bit sd rdst 1111 bnot  #%1, %0%S0 */",
11285
0
                                 op[0], op[1], op[2]);
11286
0
                          printf ("  bit = 0x%x,", bit);
11287
0
                          printf ("  sd = 0x%x,", sd);
11288
0
                          printf ("  rdst = 0x%x\n", rdst);
11289
0
                        }
11290
21.8k
                      SYNTAX("bnot  #%1, %0%S0");
11291
21.8k
#line 996 "rx-decode.opc"
11292
21.8k
                      ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
11293
11294
21.8k
                    }
11295
21.8k
                  break;
11296
113
              }
11297
60.7k
            break;
11298
60.7k
          case 0xe1:
11299
395
              GETBYTE ();
11300
395
              switch (op[2] & 0x0f)
11301
395
              {
11302
4
                case 0x00:
11303
4
                case 0x01:
11304
4
                case 0x02:
11305
4
                case 0x03:
11306
4
                case 0x04:
11307
4
                case 0x05:
11308
40
                case 0x06:
11309
73
                case 0x07:
11310
299
                case 0x08:
11311
299
                case 0x09:
11312
299
                case 0x0a:
11313
300
                case 0x0b:
11314
300
                case 0x0c:
11315
301
                case 0x0d:
11316
301
                case 0x0e:
11317
301
                  goto op_semantics_88;
11318
0
                  break;
11319
94
                case 0x0f:
11320
94
                  goto op_semantics_89;
11321
0
                  break;
11322
395
              }
11323
0
            break;
11324
54
          case 0xe2:
11325
54
              GETBYTE ();
11326
54
              switch (op[2] & 0x0f)
11327
54
              {
11328
4
                case 0x00:
11329
7
                case 0x01:
11330
12
                case 0x02:
11331
12
                case 0x03:
11332
13
                case 0x04:
11333
13
                case 0x05:
11334
13
                case 0x06:
11335
13
                case 0x07:
11336
13
                case 0x08:
11337
13
                case 0x09:
11338
17
                case 0x0a:
11339
48
                case 0x0b:
11340
48
                case 0x0c:
11341
48
                case 0x0d:
11342
48
                case 0x0e:
11343
48
                  goto op_semantics_88;
11344
0
                  break;
11345
6
                case 0x0f:
11346
6
                  goto op_semantics_89;
11347
0
                  break;
11348
54
              }
11349
0
            break;
11350
79
          case 0xe3:
11351
79
              GETBYTE ();
11352
79
              switch (op[2] & 0x0f)
11353
79
              {
11354
0
                case 0x00:
11355
17
                case 0x01:
11356
17
                case 0x02:
11357
17
                case 0x03:
11358
21
                case 0x04:
11359
21
                case 0x05:
11360
21
                case 0x06:
11361
21
                case 0x07:
11362
21
                case 0x08:
11363
22
                case 0x09:
11364
22
                case 0x0a:
11365
22
                case 0x0b:
11366
22
                case 0x0c:
11367
22
                case 0x0d:
11368
58
                case 0x0e:
11369
58
                  goto op_semantics_88;
11370
0
                  break;
11371
21
                case 0x0f:
11372
21
                  goto op_semantics_89;
11373
0
                  break;
11374
79
              }
11375
0
            break;
11376
381
          case 0xe4:
11377
381
              GETBYTE ();
11378
381
              switch (op[2] & 0x0f)
11379
381
              {
11380
57
                case 0x00:
11381
57
                case 0x01:
11382
57
                case 0x02:
11383
57
                case 0x03:
11384
300
                case 0x04:
11385
303
                case 0x05:
11386
303
                case 0x06:
11387
304
                case 0x07:
11388
304
                case 0x08:
11389
304
                case 0x09:
11390
304
                case 0x0a:
11391
312
                case 0x0b:
11392
312
                case 0x0c:
11393
366
                case 0x0d:
11394
366
                case 0x0e:
11395
366
                  goto op_semantics_88;
11396
0
                  break;
11397
15
                case 0x0f:
11398
15
                  goto op_semantics_89;
11399
0
                  break;
11400
381
              }
11401
0
            break;
11402
476
          case 0xe5:
11403
476
              GETBYTE ();
11404
476
              switch (op[2] & 0x0f)
11405
476
              {
11406
6
                case 0x00:
11407
6
                case 0x01:
11408
19
                case 0x02:
11409
19
                case 0x03:
11410
435
                case 0x04:
11411
455
                case 0x05:
11412
457
                case 0x06:
11413
461
                case 0x07:
11414
461
                case 0x08:
11415
461
                case 0x09:
11416
461
                case 0x0a:
11417
461
                case 0x0b:
11418
462
                case 0x0c:
11419
462
                case 0x0d:
11420
462
                case 0x0e:
11421
462
                  goto op_semantics_88;
11422
0
                  break;
11423
14
                case 0x0f:
11424
14
                  goto op_semantics_89;
11425
0
                  break;
11426
476
              }
11427
0
            break;
11428
49
          case 0xe6:
11429
49
              GETBYTE ();
11430
49
              switch (op[2] & 0x0f)
11431
49
              {
11432
0
                case 0x00:
11433
0
                case 0x01:
11434
0
                case 0x02:
11435
0
                case 0x03:
11436
0
                case 0x04:
11437
0
                case 0x05:
11438
21
                case 0x06:
11439
21
                case 0x07:
11440
21
                case 0x08:
11441
21
                case 0x09:
11442
23
                case 0x0a:
11443
23
                case 0x0b:
11444
23
                case 0x0c:
11445
23
                case 0x0d:
11446
23
                case 0x0e:
11447
23
                  goto op_semantics_88;
11448
0
                  break;
11449
26
                case 0x0f:
11450
26
                  goto op_semantics_89;
11451
0
                  break;
11452
49
              }
11453
0
            break;
11454
217
          case 0xe7:
11455
217
              GETBYTE ();
11456
217
              switch (op[2] & 0x0f)
11457
217
              {
11458
7
                case 0x00:
11459
7
                case 0x01:
11460
7
                case 0x02:
11461
11
                case 0x03:
11462
166
                case 0x04:
11463
166
                case 0x05:
11464
166
                case 0x06:
11465
166
                case 0x07:
11466
202
                case 0x08:
11467
202
                case 0x09:
11468
202
                case 0x0a:
11469
202
                case 0x0b:
11470
202
                case 0x0c:
11471
202
                case 0x0d:
11472
202
                case 0x0e:
11473
202
                  goto op_semantics_88;
11474
0
                  break;
11475
14
                case 0x0f:
11476
14
                  goto op_semantics_89;
11477
0
                  break;
11478
217
              }
11479
0
            break;
11480
287
          case 0xe8:
11481
287
              GETBYTE ();
11482
287
              switch (op[2] & 0x0f)
11483
287
              {
11484
13
                case 0x00:
11485
13
                case 0x01:
11486
13
                case 0x02:
11487
13
                case 0x03:
11488
17
                case 0x04:
11489
17
                case 0x05:
11490
85
                case 0x06:
11491
87
                case 0x07:
11492
235
                case 0x08:
11493
235
                case 0x09:
11494
235
                case 0x0a:
11495
235
                case 0x0b:
11496
235
                case 0x0c:
11497
235
                case 0x0d:
11498
284
                case 0x0e:
11499
284
                  goto op_semantics_88;
11500
0
                  break;
11501
3
                case 0x0f:
11502
3
                  goto op_semantics_89;
11503
0
                  break;
11504
287
              }
11505
0
            break;
11506
297
          case 0xe9:
11507
297
              GETBYTE ();
11508
297
              switch (op[2] & 0x0f)
11509
297
              {
11510
16
                case 0x00:
11511
67
                case 0x01:
11512
88
                case 0x02:
11513
103
                case 0x03:
11514
110
                case 0x04:
11515
191
                case 0x05:
11516
203
                case 0x06:
11517
203
                case 0x07:
11518
203
                case 0x08:
11519
216
                case 0x09:
11520
217
                case 0x0a:
11521
221
                case 0x0b:
11522
221
                case 0x0c:
11523
221
                case 0x0d:
11524
233
                case 0x0e:
11525
233
                  goto op_semantics_88;
11526
0
                  break;
11527
64
                case 0x0f:
11528
64
                  goto op_semantics_89;
11529
0
                  break;
11530
297
              }
11531
0
            break;
11532
73
          case 0xea:
11533
73
              GETBYTE ();
11534
73
              switch (op[2] & 0x0f)
11535
73
              {
11536
3
                case 0x00:
11537
3
                case 0x01:
11538
3
                case 0x02:
11539
3
                case 0x03:
11540
3
                case 0x04:
11541
3
                case 0x05:
11542
21
                case 0x06:
11543
21
                case 0x07:
11544
21
                case 0x08:
11545
21
                case 0x09:
11546
29
                case 0x0a:
11547
29
                case 0x0b:
11548
36
                case 0x0c:
11549
36
                case 0x0d:
11550
36
                case 0x0e:
11551
36
                  goto op_semantics_88;
11552
0
                  break;
11553
37
                case 0x0f:
11554
37
                  goto op_semantics_89;
11555
0
                  break;
11556
73
              }
11557
0
            break;
11558
520
          case 0xeb:
11559
520
              GETBYTE ();
11560
520
              switch (op[2] & 0x0f)
11561
520
              {
11562
0
                case 0x00:
11563
0
                case 0x01:
11564
0
                case 0x02:
11565
0
                case 0x03:
11566
297
                case 0x04:
11567
314
                case 0x05:
11568
314
                case 0x06:
11569
314
                case 0x07:
11570
314
                case 0x08:
11571
314
                case 0x09:
11572
314
                case 0x0a:
11573
364
                case 0x0b:
11574
364
                case 0x0c:
11575
364
                case 0x0d:
11576
364
                case 0x0e:
11577
364
                  goto op_semantics_88;
11578
0
                  break;
11579
156
                case 0x0f:
11580
156
                  goto op_semantics_89;
11581
0
                  break;
11582
520
              }
11583
0
            break;
11584
68
          case 0xec:
11585
68
              GETBYTE ();
11586
68
              switch (op[2] & 0x0f)
11587
68
              {
11588
10
                case 0x00:
11589
10
                case 0x01:
11590
13
                case 0x02:
11591
13
                case 0x03:
11592
14
                case 0x04:
11593
14
                case 0x05:
11594
14
                case 0x06:
11595
20
                case 0x07:
11596
20
                case 0x08:
11597
20
                case 0x09:
11598
20
                case 0x0a:
11599
20
                case 0x0b:
11600
53
                case 0x0c:
11601
53
                case 0x0d:
11602
53
                case 0x0e:
11603
53
                  goto op_semantics_88;
11604
0
                  break;
11605
15
                case 0x0f:
11606
15
                  goto op_semantics_89;
11607
0
                  break;
11608
68
              }
11609
0
            break;
11610
382
          case 0xed:
11611
382
              GETBYTE ();
11612
382
              switch (op[2] & 0x0f)
11613
382
              {
11614
5
                case 0x00:
11615
5
                case 0x01:
11616
5
                case 0x02:
11617
5
                case 0x03:
11618
5
                case 0x04:
11619
5
                case 0x05:
11620
5
                case 0x06:
11621
6
                case 0x07:
11622
6
                case 0x08:
11623
6
                case 0x09:
11624
6
                case 0x0a:
11625
6
                case 0x0b:
11626
6
                case 0x0c:
11627
342
                case 0x0d:
11628
345
                case 0x0e:
11629
345
                  goto op_semantics_88;
11630
0
                  break;
11631
37
                case 0x0f:
11632
37
                  goto op_semantics_89;
11633
0
                  break;
11634
382
              }
11635
0
            break;
11636
367
          case 0xee:
11637
367
              GETBYTE ();
11638
367
              switch (op[2] & 0x0f)
11639
367
              {
11640
2
                case 0x00:
11641
12
                case 0x01:
11642
12
                case 0x02:
11643
12
                case 0x03:
11644
12
                case 0x04:
11645
12
                case 0x05:
11646
12
                case 0x06:
11647
12
                case 0x07:
11648
13
                case 0x08:
11649
22
                case 0x09:
11650
301
                case 0x0a:
11651
301
                case 0x0b:
11652
309
                case 0x0c:
11653
309
                case 0x0d:
11654
315
                case 0x0e:
11655
315
                  goto op_semantics_88;
11656
0
                  break;
11657
52
                case 0x0f:
11658
52
                  goto op_semantics_89;
11659
0
                  break;
11660
367
              }
11661
0
            break;
11662
188
          case 0xef:
11663
188
              GETBYTE ();
11664
188
              switch (op[2] & 0x0f)
11665
188
              {
11666
7
                case 0x00:
11667
7
                case 0x01:
11668
7
                case 0x02:
11669
71
                case 0x03:
11670
71
                case 0x04:
11671
71
                case 0x05:
11672
71
                case 0x06:
11673
178
                case 0x07:
11674
178
                case 0x08:
11675
178
                case 0x09:
11676
178
                case 0x0a:
11677
178
                case 0x0b:
11678
181
                case 0x0c:
11679
181
                case 0x0d:
11680
181
                case 0x0e:
11681
181
                  goto op_semantics_88;
11682
0
                  break;
11683
7
                case 0x0f:
11684
7
                  goto op_semantics_89;
11685
0
                  break;
11686
188
              }
11687
0
            break;
11688
892
          case 0xf0:
11689
892
              GETBYTE ();
11690
892
              switch (op[2] & 0x0f)
11691
892
              {
11692
25
                case 0x00:
11693
26
                case 0x01:
11694
26
                case 0x02:
11695
199
                case 0x03:
11696
205
                case 0x04:
11697
205
                case 0x05:
11698
212
                case 0x06:
11699
215
                case 0x07:
11700
231
                case 0x08:
11701
257
                case 0x09:
11702
257
                case 0x0a:
11703
257
                case 0x0b:
11704
262
                case 0x0c:
11705
264
                case 0x0d:
11706
292
                case 0x0e:
11707
292
                  goto op_semantics_88;
11708
0
                  break;
11709
600
                case 0x0f:
11710
600
                  goto op_semantics_89;
11711
0
                  break;
11712
892
              }
11713
0
            break;
11714
204
          case 0xf1:
11715
204
              GETBYTE ();
11716
204
              switch (op[2] & 0x0f)
11717
204
              {
11718
4
                case 0x00:
11719
4
                case 0x01:
11720
4
                case 0x02:
11721
4
                case 0x03:
11722
86
                case 0x04:
11723
138
                case 0x05:
11724
138
                case 0x06:
11725
144
                case 0x07:
11726
157
                case 0x08:
11727
157
                case 0x09:
11728
157
                case 0x0a:
11729
157
                case 0x0b:
11730
200
                case 0x0c:
11731
201
                case 0x0d:
11732
201
                case 0x0e:
11733
201
                  goto op_semantics_88;
11734
0
                  break;
11735
3
                case 0x0f:
11736
3
                  goto op_semantics_89;
11737
0
                  break;
11738
204
              }
11739
0
            break;
11740
1.74k
          case 0xf2:
11741
1.74k
              GETBYTE ();
11742
1.74k
              switch (op[2] & 0x0f)
11743
1.74k
              {
11744
1.63k
                case 0x00:
11745
1.63k
                case 0x01:
11746
1.63k
                case 0x02:
11747
1.63k
                case 0x03:
11748
1.63k
                case 0x04:
11749
1.65k
                case 0x05:
11750
1.65k
                case 0x06:
11751
1.65k
                case 0x07:
11752
1.65k
                case 0x08:
11753
1.65k
                case 0x09:
11754
1.65k
                case 0x0a:
11755
1.65k
                case 0x0b:
11756
1.66k
                case 0x0c:
11757
1.67k
                case 0x0d:
11758
1.69k
                case 0x0e:
11759
1.69k
                  goto op_semantics_88;
11760
0
                  break;
11761
52
                case 0x0f:
11762
52
                  goto op_semantics_89;
11763
0
                  break;
11764
1.74k
              }
11765
0
            break;
11766
829
          case 0xf3:
11767
829
              GETBYTE ();
11768
829
              switch (op[2] & 0x0f)
11769
829
              {
11770
57
                case 0x00:
11771
58
                case 0x01:
11772
59
                case 0x02:
11773
136
                case 0x03:
11774
154
                case 0x04:
11775
725
                case 0x05:
11776
770
                case 0x06:
11777
773
                case 0x07:
11778
774
                case 0x08:
11779
774
                case 0x09:
11780
774
                case 0x0a:
11781
774
                case 0x0b:
11782
794
                case 0x0c:
11783
816
                case 0x0d:
11784
816
                case 0x0e:
11785
816
                  goto op_semantics_88;
11786
0
                  break;
11787
13
                case 0x0f:
11788
13
                  goto op_semantics_89;
11789
0
                  break;
11790
829
              }
11791
0
            break;
11792
442
          case 0xf4:
11793
442
              GETBYTE ();
11794
442
              switch (op[2] & 0x0f)
11795
442
              {
11796
0
                case 0x00:
11797
0
                case 0x01:
11798
0
                case 0x02:
11799
6
                case 0x03:
11800
29
                case 0x04:
11801
35
                case 0x05:
11802
36
                case 0x06:
11803
36
                case 0x07:
11804
36
                case 0x08:
11805
36
                case 0x09:
11806
36
                case 0x0a:
11807
36
                case 0x0b:
11808
415
                case 0x0c:
11809
426
                case 0x0d:
11810
426
                case 0x0e:
11811
426
                  goto op_semantics_88;
11812
0
                  break;
11813
16
                case 0x0f:
11814
16
                  goto op_semantics_89;
11815
0
                  break;
11816
442
              }
11817
0
            break;
11818
545
          case 0xf5:
11819
545
              GETBYTE ();
11820
545
              switch (op[2] & 0x0f)
11821
545
              {
11822
70
                case 0x00:
11823
123
                case 0x01:
11824
123
                case 0x02:
11825
123
                case 0x03:
11826
207
                case 0x04:
11827
221
                case 0x05:
11828
231
                case 0x06:
11829
231
                case 0x07:
11830
231
                case 0x08:
11831
231
                case 0x09:
11832
231
                case 0x0a:
11833
231
                case 0x0b:
11834
232
                case 0x0c:
11835
239
                case 0x0d:
11836
239
                case 0x0e:
11837
239
                  goto op_semantics_88;
11838
0
                  break;
11839
306
                case 0x0f:
11840
306
                  goto op_semantics_89;
11841
0
                  break;
11842
545
              }
11843
0
            break;
11844
113
          case 0xf6:
11845
113
              GETBYTE ();
11846
113
              switch (op[2] & 0x0f)
11847
113
              {
11848
0
                case 0x00:
11849
0
                case 0x01:
11850
0
                case 0x02:
11851
33
                case 0x03:
11852
34
                case 0x04:
11853
39
                case 0x05:
11854
45
                case 0x06:
11855
45
                case 0x07:
11856
45
                case 0x08:
11857
46
                case 0x09:
11858
49
                case 0x0a:
11859
49
                case 0x0b:
11860
49
                case 0x0c:
11861
49
                case 0x0d:
11862
49
                case 0x0e:
11863
49
                  goto op_semantics_88;
11864
0
                  break;
11865
64
                case 0x0f:
11866
64
                  goto op_semantics_89;
11867
0
                  break;
11868
113
              }
11869
0
            break;
11870
106
          case 0xf7:
11871
106
              GETBYTE ();
11872
106
              switch (op[2] & 0x0f)
11873
106
              {
11874
0
                case 0x00:
11875
0
                case 0x01:
11876
0
                case 0x02:
11877
29
                case 0x03:
11878
29
                case 0x04:
11879
29
                case 0x05:
11880
55
                case 0x06:
11881
55
                case 0x07:
11882
55
                case 0x08:
11883
55
                case 0x09:
11884
55
                case 0x0a:
11885
57
                case 0x0b:
11886
67
                case 0x0c:
11887
67
                case 0x0d:
11888
67
                case 0x0e:
11889
67
                  goto op_semantics_88;
11890
0
                  break;
11891
39
                case 0x0f:
11892
39
                  goto op_semantics_89;
11893
0
                  break;
11894
106
              }
11895
0
            break;
11896
216
          case 0xf8:
11897
216
              GETBYTE ();
11898
216
              switch (op[2] & 0x0f)
11899
216
              {
11900
27
                case 0x00:
11901
27
                case 0x01:
11902
27
                case 0x02:
11903
27
                case 0x03:
11904
40
                case 0x04:
11905
42
                case 0x05:
11906
42
                case 0x06:
11907
42
                case 0x07:
11908
49
                case 0x08:
11909
49
                case 0x09:
11910
49
                case 0x0a:
11911
49
                case 0x0b:
11912
78
                case 0x0c:
11913
78
                case 0x0d:
11914
107
                case 0x0e:
11915
107
                  goto op_semantics_88;
11916
0
                  break;
11917
109
                case 0x0f:
11918
109
                  goto op_semantics_89;
11919
0
                  break;
11920
216
              }
11921
0
            break;
11922
488
          case 0xf9:
11923
488
              GETBYTE ();
11924
488
              switch (op[2] & 0x0f)
11925
488
              {
11926
13
                case 0x00:
11927
54
                case 0x01:
11928
54
                case 0x02:
11929
347
                case 0x03:
11930
347
                case 0x04:
11931
353
                case 0x05:
11932
363
                case 0x06:
11933
363
                case 0x07:
11934
364
                case 0x08:
11935
366
                case 0x09:
11936
366
                case 0x0a:
11937
373
                case 0x0b:
11938
386
                case 0x0c:
11939
388
                case 0x0d:
11940
388
                case 0x0e:
11941
388
                  goto op_semantics_88;
11942
0
                  break;
11943
93
                case 0x0f:
11944
93
                  goto op_semantics_89;
11945
0
                  break;
11946
488
              }
11947
0
            break;
11948
286
          case 0xfa:
11949
286
              GETBYTE ();
11950
286
              switch (op[2] & 0x0f)
11951
286
              {
11952
61
                case 0x00:
11953
70
                case 0x01:
11954
70
                case 0x02:
11955
80
                case 0x03:
11956
81
                case 0x04:
11957
168
                case 0x05:
11958
169
                case 0x06:
11959
169
                case 0x07:
11960
171
                case 0x08:
11961
175
                case 0x09:
11962
191
                case 0x0a:
11963
191
                case 0x0b:
11964
195
                case 0x0c:
11965
195
                case 0x0d:
11966
196
                case 0x0e:
11967
196
                  goto op_semantics_88;
11968
0
                  break;
11969
90
                case 0x0f:
11970
90
                  goto op_semantics_89;
11971
0
                  break;
11972
286
              }
11973
0
            break;
11974
230
          case 0xfb:
11975
230
              GETBYTE ();
11976
230
              switch (op[2] & 0x0f)
11977
230
              {
11978
36
                case 0x00:
11979
36
                case 0x01:
11980
36
                case 0x02:
11981
43
                case 0x03:
11982
47
                case 0x04:
11983
47
                case 0x05:
11984
47
                case 0x06:
11985
47
                case 0x07:
11986
47
                case 0x08:
11987
47
                case 0x09:
11988
47
                case 0x0a:
11989
51
                case 0x0b:
11990
193
                case 0x0c:
11991
193
                case 0x0d:
11992
208
                case 0x0e:
11993
208
                  goto op_semantics_88;
11994
0
                  break;
11995
22
                case 0x0f:
11996
22
                  goto op_semantics_89;
11997
0
                  break;
11998
230
              }
11999
0
            break;
12000
25.9k
          case 0xfc:
12001
25.9k
              GETBYTE ();
12002
25.9k
              switch (op[2] & 0x0f)
12003
25.9k
              {
12004
988
                case 0x00:
12005
1.40k
                case 0x01:
12006
1.54k
                case 0x02:
12007
2.53k
                case 0x03:
12008
2.84k
                case 0x04:
12009
2.90k
                case 0x05:
12010
2.97k
                case 0x06:
12011
3.08k
                case 0x07:
12012
3.26k
                case 0x08:
12013
3.50k
                case 0x09:
12014
3.58k
                case 0x0a:
12015
3.66k
                case 0x0b:
12016
23.9k
                case 0x0c:
12017
24.8k
                case 0x0d:
12018
25.0k
                case 0x0e:
12019
25.0k
                  goto op_semantics_88;
12020
0
                  break;
12021
856
                case 0x0f:
12022
856
                  goto op_semantics_89;
12023
0
                  break;
12024
25.9k
              }
12025
0
            break;
12026
1.56k
          case 0xfd:
12027
1.56k
              GETBYTE ();
12028
1.56k
              switch (op[2] & 0x0f)
12029
1.56k
              {
12030
26
                case 0x00:
12031
60
                case 0x01:
12032
74
                case 0x02:
12033
107
                case 0x03:
12034
223
                case 0x04:
12035
223
                case 0x05:
12036
258
                case 0x06:
12037
260
                case 0x07:
12038
297
                case 0x08:
12039
322
                case 0x09:
12040
337
                case 0x0a:
12041
342
                case 0x0b:
12042
646
                case 0x0c:
12043
1.49k
                case 0x0d:
12044
1.50k
                case 0x0e:
12045
1.50k
                  goto op_semantics_88;
12046
0
                  break;
12047
61
                case 0x0f:
12048
61
                  goto op_semantics_89;
12049
0
                  break;
12050
1.56k
              }
12051
0
            break;
12052
1.45k
          case 0xfe:
12053
1.45k
              GETBYTE ();
12054
1.45k
              switch (op[2] & 0x0f)
12055
1.45k
              {
12056
874
                case 0x00:
12057
891
                case 0x01:
12058
891
                case 0x02:
12059
894
                case 0x03:
12060
899
                case 0x04:
12061
900
                case 0x05:
12062
901
                case 0x06:
12063
901
                case 0x07:
12064
901
                case 0x08:
12065
901
                case 0x09:
12066
1.21k
                case 0x0a:
12067
1.21k
                case 0x0b:
12068
1.30k
                case 0x0c:
12069
1.30k
                case 0x0d:
12070
1.34k
                case 0x0e:
12071
1.34k
                  goto op_semantics_88;
12072
0
                  break;
12073
110
                case 0x0f:
12074
110
                  goto op_semantics_89;
12075
0
                  break;
12076
1.45k
              }
12077
0
            break;
12078
21.7k
          case 0xff:
12079
21.7k
              GETBYTE ();
12080
21.7k
              switch (op[2] & 0x0f)
12081
21.7k
              {
12082
429
                case 0x00:
12083
442
                case 0x01:
12084
450
                case 0x02:
12085
491
                case 0x03:
12086
1.59k
                case 0x04:
12087
1.67k
                case 0x05:
12088
1.67k
                case 0x06:
12089
2.13k
                case 0x07:
12090
2.51k
                case 0x08:
12091
2.53k
                case 0x09:
12092
2.57k
                case 0x0a:
12093
2.63k
                case 0x0b:
12094
2.78k
                case 0x0c:
12095
2.80k
                case 0x0d:
12096
2.95k
                case 0x0e:
12097
2.95k
                  goto op_semantics_88;
12098
0
                  break;
12099
18.8k
                case 0x0f:
12100
18.8k
                  goto op_semantics_89;
12101
0
                  break;
12102
21.7k
              }
12103
0
            break;
12104
17.6k
          default: UNSUPPORTED(); break;
12105
105k
        }
12106
105k
      break;
12107
105k
    case 0xfd:
12108
97.6k
        GETBYTE ();
12109
97.6k
        switch (op[1] & 0xff)
12110
97.6k
        {
12111
2.98k
          case 0x00:
12112
2.98k
              GETBYTE ();
12113
2.98k
              switch (op[2] & 0x00)
12114
2.98k
              {
12115
2.98k
                case 0x00:
12116
3.25k
                  op_semantics_90:
12117
3.25k
                    {
12118
                      /** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */
12119
3.25k
#line 873 "rx-decode.opc"
12120
3.25k
                      int a AU = (op[1] >> 3) & 0x01;
12121
3.25k
#line 873 "rx-decode.opc"
12122
3.25k
                      int srca AU = (op[2] >> 4) & 0x0f;
12123
3.25k
#line 873 "rx-decode.opc"
12124
3.25k
                      int srcb AU = op[2] & 0x0f;
12125
3.25k
                      if (trace)
12126
0
                        {
12127
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12128
0
                                 "/** 1111 1101 0000 a000 srca srcb mulhi %1, %2, %0 */",
12129
0
                                 op[0], op[1], op[2]);
12130
0
                          printf ("  a = 0x%x,", a);
12131
0
                          printf ("  srca = 0x%x,", srca);
12132
0
                          printf ("  srcb = 0x%x\n", srcb);
12133
0
                        }
12134
3.25k
                      SYNTAX("mulhi %1, %2, %0");
12135
3.25k
#line 873 "rx-decode.opc"
12136
3.25k
                      ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137
12138
3.25k
                    }
12139
3.25k
                  break;
12140
2.98k
              }
12141
3.25k
            break;
12142
3.25k
          case 0x01:
12143
526
              GETBYTE ();
12144
526
              switch (op[2] & 0x00)
12145
526
              {
12146
526
                case 0x00:
12147
869
                  op_semantics_91:
12148
869
                    {
12149
                      /** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */
12150
869
#line 876 "rx-decode.opc"
12151
869
                      int a AU = (op[1] >> 3) & 0x01;
12152
869
#line 876 "rx-decode.opc"
12153
869
                      int srca AU = (op[2] >> 4) & 0x0f;
12154
869
#line 876 "rx-decode.opc"
12155
869
                      int srcb AU = op[2] & 0x0f;
12156
869
                      if (trace)
12157
0
                        {
12158
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12159
0
                                 "/** 1111 1101 0000 a001 srca srcb mullo %1, %2, %0 */",
12160
0
                                 op[0], op[1], op[2]);
12161
0
                          printf ("  a = 0x%x,", a);
12162
0
                          printf ("  srca = 0x%x,", srca);
12163
0
                          printf ("  srcb = 0x%x\n", srcb);
12164
0
                        }
12165
869
                      SYNTAX("mullo %1, %2, %0");
12166
869
#line 876 "rx-decode.opc"
12167
869
                      ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168
12169
869
                    }
12170
869
                  break;
12171
526
              }
12172
869
            break;
12173
869
          case 0x02:
12174
45
              GETBYTE ();
12175
45
              switch (op[2] & 0x00)
12176
45
              {
12177
45
                case 0x00:
12178
391
                  op_semantics_92:
12179
391
                    {
12180
                      /** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */
12181
391
#line 1104 "rx-decode.opc"
12182
391
                      int a AU = (op[1] >> 3) & 0x01;
12183
391
#line 1104 "rx-decode.opc"
12184
391
                      int srca AU = (op[2] >> 4) & 0x0f;
12185
391
#line 1104 "rx-decode.opc"
12186
391
                      int srcb AU = op[2] & 0x0f;
12187
391
                      if (trace)
12188
0
                        {
12189
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12190
0
                                 "/** 1111 1101 0000 a010 srca srcb mullh %1, %2, %0 */",
12191
0
                                 op[0], op[1], op[2]);
12192
0
                          printf ("  a = 0x%x,", a);
12193
0
                          printf ("  srca = 0x%x,", srca);
12194
0
                          printf ("  srcb = 0x%x\n", srcb);
12195
0
                        }
12196
391
                      SYNTAX("mullh %1, %2, %0");
12197
391
#line 1104 "rx-decode.opc"
12198
391
                      ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199
12200
391
                    }
12201
391
                  break;
12202
45
              }
12203
391
            break;
12204
391
          case 0x03:
12205
125
              GETBYTE ();
12206
125
              switch (op[2] & 0x00)
12207
125
              {
12208
125
                case 0x00:
12209
268
                  op_semantics_93:
12210
268
                    {
12211
                      /** 1111 1101 0000 a011 srca srcb   emula %1, %2, %0 */
12212
268
#line 1089 "rx-decode.opc"
12213
268
                      int a AU = (op[1] >> 3) & 0x01;
12214
268
#line 1089 "rx-decode.opc"
12215
268
                      int srca AU = (op[2] >> 4) & 0x0f;
12216
268
#line 1089 "rx-decode.opc"
12217
268
                      int srcb AU = op[2] & 0x0f;
12218
268
                      if (trace)
12219
0
                        {
12220
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12221
0
                                 "/** 1111 1101 0000 a011 srca srcb   emula %1, %2, %0 */",
12222
0
                                 op[0], op[1], op[2]);
12223
0
                          printf ("  a = 0x%x,", a);
12224
0
                          printf ("  srca = 0x%x,", srca);
12225
0
                          printf ("  srcb = 0x%x\n", srcb);
12226
0
                        }
12227
268
                      SYNTAX("emula %1, %2, %0");
12228
268
#line 1089 "rx-decode.opc"
12229
268
                      ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230
12231
268
                    }
12232
268
                  break;
12233
125
              }
12234
268
            break;
12235
268
          case 0x04:
12236
109
              GETBYTE ();
12237
109
              switch (op[2] & 0x00)
12238
109
              {
12239
109
                case 0x00:
12240
296
                  op_semantics_94:
12241
296
                    {
12242
                      /** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */
12243
296
#line 879 "rx-decode.opc"
12244
296
                      int a AU = (op[1] >> 3) & 0x01;
12245
296
#line 879 "rx-decode.opc"
12246
296
                      int srca AU = (op[2] >> 4) & 0x0f;
12247
296
#line 879 "rx-decode.opc"
12248
296
                      int srcb AU = op[2] & 0x0f;
12249
296
                      if (trace)
12250
0
                        {
12251
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12252
0
                                 "/** 1111 1101 0000 a100 srca srcb machi %1, %2, %0 */",
12253
0
                                 op[0], op[1], op[2]);
12254
0
                          printf ("  a = 0x%x,", a);
12255
0
                          printf ("  srca = 0x%x,", srca);
12256
0
                          printf ("  srcb = 0x%x\n", srcb);
12257
0
                        }
12258
296
                      SYNTAX("machi %1, %2, %0");
12259
296
#line 879 "rx-decode.opc"
12260
296
                      ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261
12262
296
                    }
12263
296
                  break;
12264
109
              }
12265
296
            break;
12266
425
          case 0x05:
12267
425
              GETBYTE ();
12268
425
              switch (op[2] & 0x00)
12269
425
              {
12270
425
                case 0x00:
12271
539
                  op_semantics_95:
12272
539
                    {
12273
                      /** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */
12274
539
#line 882 "rx-decode.opc"
12275
539
                      int a AU = (op[1] >> 3) & 0x01;
12276
539
#line 882 "rx-decode.opc"
12277
539
                      int srca AU = (op[2] >> 4) & 0x0f;
12278
539
#line 882 "rx-decode.opc"
12279
539
                      int srcb AU = op[2] & 0x0f;
12280
539
                      if (trace)
12281
0
                        {
12282
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12283
0
                                 "/** 1111 1101 0000 a101 srca srcb maclo %1, %2, %0 */",
12284
0
                                 op[0], op[1], op[2]);
12285
0
                          printf ("  a = 0x%x,", a);
12286
0
                          printf ("  srca = 0x%x,", srca);
12287
0
                          printf ("  srcb = 0x%x\n", srcb);
12288
0
                        }
12289
539
                      SYNTAX("maclo %1, %2, %0");
12290
539
#line 882 "rx-decode.opc"
12291
539
                      ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292
12293
539
                    }
12294
539
                  break;
12295
425
              }
12296
539
            break;
12297
1.78k
          case 0x06:
12298
1.78k
              GETBYTE ();
12299
1.78k
              switch (op[2] & 0x00)
12300
1.78k
              {
12301
1.78k
                case 0x00:
12302
1.85k
                  op_semantics_96:
12303
1.85k
                    {
12304
                      /** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */
12305
1.85k
#line 1092 "rx-decode.opc"
12306
1.85k
                      int a AU = (op[1] >> 3) & 0x01;
12307
1.85k
#line 1092 "rx-decode.opc"
12308
1.85k
                      int srca AU = (op[2] >> 4) & 0x0f;
12309
1.85k
#line 1092 "rx-decode.opc"
12310
1.85k
                      int srcb AU = op[2] & 0x0f;
12311
1.85k
                      if (trace)
12312
0
                        {
12313
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12314
0
                                 "/** 1111 1101 0000 a110 srca srcb maclh %1, %2, %0 */",
12315
0
                                 op[0], op[1], op[2]);
12316
0
                          printf ("  a = 0x%x,", a);
12317
0
                          printf ("  srca = 0x%x,", srca);
12318
0
                          printf ("  srcb = 0x%x\n", srcb);
12319
0
                        }
12320
1.85k
                      SYNTAX("maclh %1, %2, %0");
12321
1.85k
#line 1092 "rx-decode.opc"
12322
1.85k
                      ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
12323
12324
1.85k
                    }
12325
1.85k
                  break;
12326
1.78k
              }
12327
1.85k
            break;
12328
1.85k
          case 0x07:
12329
111
              GETBYTE ();
12330
111
              switch (op[2] & 0x00)
12331
111
              {
12332
111
                case 0x00:
12333
227
                  op_semantics_97:
12334
227
                    {
12335
                      /** 1111 1101 0000 a111 srca srcb   emaca %1, %2, %0 */
12336
227
#line 1083 "rx-decode.opc"
12337
227
                      int a AU = (op[1] >> 3) & 0x01;
12338
227
#line 1083 "rx-decode.opc"
12339
227
                      int srca AU = (op[2] >> 4) & 0x0f;
12340
227
#line 1083 "rx-decode.opc"
12341
227
                      int srcb AU = op[2] & 0x0f;
12342
227
                      if (trace)
12343
0
                        {
12344
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12345
0
                                 "/** 1111 1101 0000 a111 srca srcb   emaca %1, %2, %0 */",
12346
0
                                 op[0], op[1], op[2]);
12347
0
                          printf ("  a = 0x%x,", a);
12348
0
                          printf ("  srca = 0x%x,", srca);
12349
0
                          printf ("  srcb = 0x%x\n", srcb);
12350
0
                        }
12351
227
                      SYNTAX("emaca %1, %2, %0");
12352
227
#line 1083 "rx-decode.opc"
12353
227
                      ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
12354
12355
227
                    }
12356
227
                  break;
12357
111
              }
12358
227
            break;
12359
266
          case 0x08:
12360
266
              GETBYTE ();
12361
266
              switch (op[2] & 0x00)
12362
266
              {
12363
266
                case 0x00:
12364
266
                  goto op_semantics_90;
12365
0
                  break;
12366
266
              }
12367
0
            break;
12368
343
          case 0x09:
12369
343
              GETBYTE ();
12370
343
              switch (op[2] & 0x00)
12371
343
              {
12372
343
                case 0x00:
12373
343
                  goto op_semantics_91;
12374
0
                  break;
12375
343
              }
12376
0
            break;
12377
346
          case 0x0a:
12378
346
              GETBYTE ();
12379
346
              switch (op[2] & 0x00)
12380
346
              {
12381
346
                case 0x00:
12382
346
                  goto op_semantics_92;
12383
0
                  break;
12384
346
              }
12385
0
            break;
12386
145
          case 0x0b:
12387
145
              GETBYTE ();
12388
145
              switch (op[2] & 0x00)
12389
145
              {
12390
143
                case 0x00:
12391
143
                  goto op_semantics_93;
12392
0
                  break;
12393
145
              }
12394
0
            break;
12395
187
          case 0x0c:
12396
187
              GETBYTE ();
12397
187
              switch (op[2] & 0x00)
12398
187
              {
12399
187
                case 0x00:
12400
187
                  goto op_semantics_94;
12401
0
                  break;
12402
187
              }
12403
0
            break;
12404
114
          case 0x0d:
12405
114
              GETBYTE ();
12406
114
              switch (op[2] & 0x00)
12407
114
              {
12408
114
                case 0x00:
12409
114
                  goto op_semantics_95;
12410
0
                  break;
12411
114
              }
12412
0
            break;
12413
65
          case 0x0e:
12414
65
              GETBYTE ();
12415
65
              switch (op[2] & 0x00)
12416
65
              {
12417
64
                case 0x00:
12418
64
                  goto op_semantics_96;
12419
0
                  break;
12420
65
              }
12421
0
            break;
12422
116
          case 0x0f:
12423
116
              GETBYTE ();
12424
116
              switch (op[2] & 0x00)
12425
116
              {
12426
116
                case 0x00:
12427
116
                  goto op_semantics_97;
12428
0
                  break;
12429
116
              }
12430
0
            break;
12431
84
          case 0x17:
12432
84
              GETBYTE ();
12433
84
              switch (op[2] & 0x70)
12434
84
              {
12435
57
                case 0x00:
12436
57
                    {
12437
                      /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438
57
#line 885 "rx-decode.opc"
12439
57
                      int a AU = (op[2] >> 7) & 0x01;
12440
57
#line 885 "rx-decode.opc"
12441
57
                      int rsrc AU = op[2] & 0x0f;
12442
57
                      if (trace)
12443
0
                        {
12444
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12445
0
                                 "/** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */",
12446
0
                                 op[0], op[1], op[2]);
12447
0
                          printf ("  a = 0x%x,", a);
12448
0
                          printf ("  rsrc = 0x%x\n", rsrc);
12449
0
                        }
12450
57
                      SYNTAX("mvtachi %1, %0");
12451
57
#line 885 "rx-decode.opc"
12452
57
                      ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453
12454
57
                    }
12455
57
                  break;
12456
20
                case 0x10:
12457
20
                    {
12458
                      /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459
20
#line 888 "rx-decode.opc"
12460
20
                      int a AU = (op[2] >> 7) & 0x01;
12461
20
#line 888 "rx-decode.opc"
12462
20
                      int rsrc AU = op[2] & 0x0f;
12463
20
                      if (trace)
12464
0
                        {
12465
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12466
0
                                 "/** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */",
12467
0
                                 op[0], op[1], op[2]);
12468
0
                          printf ("  a = 0x%x,", a);
12469
0
                          printf ("  rsrc = 0x%x\n", rsrc);
12470
0
                        }
12471
20
                      SYNTAX("mvtaclo %1, %0");
12472
20
#line 888 "rx-decode.opc"
12473
20
                      ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474
12475
20
                    }
12476
20
                  break;
12477
1
                case 0x30:
12478
1
                    {
12479
                      /** 1111 1101 0001 0111 a011 rsrc mvtacgu %1, %0 */
12480
1
#line 1110 "rx-decode.opc"
12481
1
                      int a AU = (op[2] >> 7) & 0x01;
12482
1
#line 1110 "rx-decode.opc"
12483
1
                      int rsrc AU = op[2] & 0x0f;
12484
1
                      if (trace)
12485
0
                        {
12486
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12487
0
                                 "/** 1111 1101 0001 0111 a011 rsrc mvtacgu %1, %0 */",
12488
0
                                 op[0], op[1], op[2]);
12489
0
                          printf ("  a = 0x%x,", a);
12490
0
                          printf ("  rsrc = 0x%x\n", rsrc);
12491
0
                        }
12492
1
                      SYNTAX("mvtacgu %1, %0");
12493
1
#line 1110 "rx-decode.opc"
12494
1
                      ID(mvtacgu); SR(rsrc); DR(a+32); F_____;
12495
12496
1
                    }
12497
1
                  break;
12498
6
                default: UNSUPPORTED(); break;
12499
84
              }
12500
84
            break;
12501
172
          case 0x18:
12502
172
              GETBYTE ();
12503
172
              switch (op[2] & 0x6f)
12504
172
              {
12505
19
                case 0x00:
12506
19
                    {
12507
                      /** 1111 1101 0001 1000 a00i 0000 racw  #%1, %0 */
12508
19
#line 900 "rx-decode.opc"
12509
19
                      int a AU = (op[2] >> 7) & 0x01;
12510
19
#line 900 "rx-decode.opc"
12511
19
                      int i AU = (op[2] >> 4) & 0x01;
12512
19
                      if (trace)
12513
0
                        {
12514
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12515
0
                                 "/** 1111 1101 0001 1000 a00i 0000 racw  #%1, %0 */",
12516
0
                                 op[0], op[1], op[2]);
12517
0
                          printf ("  a = 0x%x,", a);
12518
0
                          printf ("  i = 0x%x\n", i);
12519
0
                        }
12520
19
                      SYNTAX("racw  #%1, %0");
12521
19
#line 900 "rx-decode.opc"
12522
19
                      ID(racw); SC(i+1); DR(a+32); F_____;
12523
12524
                    /*----------------------------------------------------------------------*/
12525
                    /* SAT                  */
12526
12527
19
                    }
12528
19
                  break;
12529
53
                case 0x40:
12530
53
                    {
12531
                      /** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */
12532
53
#line 1119 "rx-decode.opc"
12533
53
                      int a AU = (op[2] >> 7) & 0x01;
12534
53
#line 1119 "rx-decode.opc"
12535
53
                      int i AU = (op[2] >> 4) & 0x01;
12536
53
                      if (trace)
12537
0
                        {
12538
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12539
0
                                 "/** 1111 1101 0001 1000 a10i 0000 rdacw #%1, %0 */",
12540
0
                                 op[0], op[1], op[2]);
12541
0
                          printf ("  a = 0x%x,", a);
12542
0
                          printf ("  i = 0x%x\n", i);
12543
0
                        }
12544
53
                      SYNTAX("rdacw #%1, %0");
12545
53
#line 1119 "rx-decode.opc"
12546
53
                      ID(rdacw); SC(i+1); DR(a+32); F_____;
12547
12548
53
                    }
12549
53
                  break;
12550
100
                default: UNSUPPORTED(); break;
12551
172
              }
12552
172
            break;
12553
531
          case 0x19:
12554
531
              GETBYTE ();
12555
531
              switch (op[2] & 0x6f)
12556
531
              {
12557
47
                case 0x00:
12558
47
                    {
12559
                      /** 1111 1101 0001 1001 a00i 0000 racl  #%1, %0 */
12560
47
#line 1113 "rx-decode.opc"
12561
47
                      int a AU = (op[2] >> 7) & 0x01;
12562
47
#line 1113 "rx-decode.opc"
12563
47
                      int i AU = (op[2] >> 4) & 0x01;
12564
47
                      if (trace)
12565
0
                        {
12566
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12567
0
                                 "/** 1111 1101 0001 1001 a00i 0000 racl  #%1, %0 */",
12568
0
                                 op[0], op[1], op[2]);
12569
0
                          printf ("  a = 0x%x,", a);
12570
0
                          printf ("  i = 0x%x\n", i);
12571
0
                        }
12572
47
                      SYNTAX("racl  #%1, %0");
12573
47
#line 1113 "rx-decode.opc"
12574
47
                      ID(racl); SC(i+1); DR(a+32); F_____;
12575
12576
47
                    }
12577
47
                  break;
12578
6
                case 0x40:
12579
6
                    {
12580
                      /** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */
12581
6
#line 1116 "rx-decode.opc"
12582
6
                      int a AU = (op[2] >> 7) & 0x01;
12583
6
#line 1116 "rx-decode.opc"
12584
6
                      int i AU = (op[2] >> 4) & 0x01;
12585
6
                      if (trace)
12586
0
                        {
12587
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12588
0
                                 "/** 1111 1101 0001 1001 a10i 0000 rdacl #%1, %0 */",
12589
0
                                 op[0], op[1], op[2]);
12590
0
                          printf ("  a = 0x%x,", a);
12591
0
                          printf ("  i = 0x%x\n", i);
12592
0
                        }
12593
6
                      SYNTAX("rdacl #%1, %0");
12594
6
#line 1116 "rx-decode.opc"
12595
6
                      ID(rdacl); SC(i+1); DR(a+32); F_____;
12596
12597
6
                    }
12598
6
                  break;
12599
478
                default: UNSUPPORTED(); break;
12600
531
              }
12601
531
            break;
12602
531
          case 0x1e:
12603
166
              GETBYTE ();
12604
166
              switch (op[2] & 0x30)
12605
166
              {
12606
20
                case 0x00:
12607
153
                  op_semantics_98:
12608
153
                    {
12609
                      /** 1111 1101 0001 111i a m00 rdst  mvfachi #%2, %1, %0 */
12610
153
#line 891 "rx-decode.opc"
12611
153
                      int i AU = op[1] & 0x01;
12612
153
#line 891 "rx-decode.opc"
12613
153
                      int a AU = (op[2] >> 7) & 0x01;
12614
153
#line 891 "rx-decode.opc"
12615
153
                      int m AU = (op[2] >> 6) & 0x01;
12616
153
#line 891 "rx-decode.opc"
12617
153
                      int rdst AU = op[2] & 0x0f;
12618
153
                      if (trace)
12619
0
                        {
12620
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12621
0
                                 "/** 1111 1101 0001 111i a m00 rdst  mvfachi #%2, %1, %0 */",
12622
0
                                 op[0], op[1], op[2]);
12623
0
                          printf ("  i = 0x%x,", i);
12624
0
                          printf ("  a = 0x%x,", a);
12625
0
                          printf ("  m = 0x%x,", m);
12626
0
                          printf ("  rdst = 0x%x\n", rdst);
12627
0
                        }
12628
153
                      SYNTAX("mvfachi #%2, %1, %0");
12629
153
#line 891 "rx-decode.opc"
12630
153
                      ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631
12632
153
                    }
12633
153
                  break;
12634
37
                case 0x10:
12635
39
                  op_semantics_99:
12636
39
                    {
12637
                      /** 1111 1101 0001 111i a m01 rdst  mvfaclo #%2, %1, %0 */
12638
39
#line 897 "rx-decode.opc"
12639
39
                      int i AU = op[1] & 0x01;
12640
39
#line 897 "rx-decode.opc"
12641
39
                      int a AU = (op[2] >> 7) & 0x01;
12642
39
#line 897 "rx-decode.opc"
12643
39
                      int m AU = (op[2] >> 6) & 0x01;
12644
39
#line 897 "rx-decode.opc"
12645
39
                      int rdst AU = op[2] & 0x0f;
12646
39
                      if (trace)
12647
0
                        {
12648
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12649
0
                                 "/** 1111 1101 0001 111i a m01 rdst  mvfaclo #%2, %1, %0 */",
12650
0
                                 op[0], op[1], op[2]);
12651
0
                          printf ("  i = 0x%x,", i);
12652
0
                          printf ("  a = 0x%x,", a);
12653
0
                          printf ("  m = 0x%x,", m);
12654
0
                          printf ("  rdst = 0x%x\n", rdst);
12655
0
                        }
12656
39
                      SYNTAX("mvfaclo #%2, %1, %0");
12657
39
#line 897 "rx-decode.opc"
12658
39
                      ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659
12660
39
                    }
12661
39
                  break;
12662
23
                case 0x20:
12663
115
                  op_semantics_100:
12664
115
                    {
12665
                      /** 1111 1101 0001 111i a m10 rdst  mvfacmi #%2, %1, %0 */
12666
115
#line 894 "rx-decode.opc"
12667
115
                      int i AU = op[1] & 0x01;
12668
115
#line 894 "rx-decode.opc"
12669
115
                      int a AU = (op[2] >> 7) & 0x01;
12670
115
#line 894 "rx-decode.opc"
12671
115
                      int m AU = (op[2] >> 6) & 0x01;
12672
115
#line 894 "rx-decode.opc"
12673
115
                      int rdst AU = op[2] & 0x0f;
12674
115
                      if (trace)
12675
0
                        {
12676
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12677
0
                                 "/** 1111 1101 0001 111i a m10 rdst  mvfacmi #%2, %1, %0 */",
12678
0
                                 op[0], op[1], op[2]);
12679
0
                          printf ("  i = 0x%x,", i);
12680
0
                          printf ("  a = 0x%x,", a);
12681
0
                          printf ("  m = 0x%x,", m);
12682
0
                          printf ("  rdst = 0x%x\n", rdst);
12683
0
                        }
12684
115
                      SYNTAX("mvfacmi #%2, %1, %0");
12685
115
#line 894 "rx-decode.opc"
12686
115
                      ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687
12688
115
                    }
12689
115
                  break;
12690
86
                case 0x30:
12691
94
                  op_semantics_101:
12692
94
                    {
12693
                      /** 1111 1101 0001 111i a m11 rdst  mvfacgu #%2, %1, %0 */
12694
94
#line 1107 "rx-decode.opc"
12695
94
                      int i AU = op[1] & 0x01;
12696
94
#line 1107 "rx-decode.opc"
12697
94
                      int a AU = (op[2] >> 7) & 0x01;
12698
94
#line 1107 "rx-decode.opc"
12699
94
                      int m AU = (op[2] >> 6) & 0x01;
12700
94
#line 1107 "rx-decode.opc"
12701
94
                      int rdst AU = op[2] & 0x0f;
12702
94
                      if (trace)
12703
0
                        {
12704
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12705
0
                                 "/** 1111 1101 0001 111i a m11 rdst  mvfacgu #%2, %1, %0 */",
12706
0
                                 op[0], op[1], op[2]);
12707
0
                          printf ("  i = 0x%x,", i);
12708
0
                          printf ("  a = 0x%x,", a);
12709
0
                          printf ("  m = 0x%x,", m);
12710
0
                          printf ("  rdst = 0x%x\n", rdst);
12711
0
                        }
12712
94
                      SYNTAX("mvfacgu #%2, %1, %0");
12713
94
#line 1107 "rx-decode.opc"
12714
94
                      ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715
12716
94
                    }
12717
94
                  break;
12718
166
              }
12719
401
            break;
12720
401
          case 0x1f:
12721
235
              GETBYTE ();
12722
235
              switch (op[2] & 0x30)
12723
235
              {
12724
133
                case 0x00:
12725
133
                  goto op_semantics_98;
12726
0
                  break;
12727
2
                case 0x10:
12728
2
                  goto op_semantics_99;
12729
0
                  break;
12730
92
                case 0x20:
12731
92
                  goto op_semantics_100;
12732
0
                  break;
12733
8
                case 0x30:
12734
8
                  goto op_semantics_101;
12735
0
                  break;
12736
235
              }
12737
0
            break;
12738
98
          case 0x20:
12739
98
              GETBYTE ();
12740
98
              switch (op[2] & 0x00)
12741
98
              {
12742
98
                case 0x00:
12743
574
                  op_semantics_102:
12744
574
                    {
12745
                      /** 1111 1101 0010 0p sz rdst rsrc  mov%s %1, %0 */
12746
574
#line 369 "rx-decode.opc"
12747
574
                      int p AU = (op[1] >> 2) & 0x01;
12748
574
#line 369 "rx-decode.opc"
12749
574
                      int sz AU = op[1] & 0x03;
12750
574
#line 369 "rx-decode.opc"
12751
574
                      int rdst AU = (op[2] >> 4) & 0x0f;
12752
574
#line 369 "rx-decode.opc"
12753
574
                      int rsrc AU = op[2] & 0x0f;
12754
574
                      if (trace)
12755
0
                        {
12756
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12757
0
                                 "/** 1111 1101 0010 0p sz rdst rsrc  mov%s %1, %0 */",
12758
0
                                 op[0], op[1], op[2]);
12759
0
                          printf ("  p = 0x%x,", p);
12760
0
                          printf ("  sz = 0x%x,", sz);
12761
0
                          printf ("  rdst = 0x%x,", rdst);
12762
0
                          printf ("  rsrc = 0x%x\n", rsrc);
12763
0
                        }
12764
574
                      SYNTAX("mov%s %1, %0");
12765
574
#line 369 "rx-decode.opc"
12766
574
                      ID(mov); sBWL (sz); SR(rsrc); F_____;
12767
574
                      OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768
12769
574
                    }
12770
574
                  break;
12771
98
              }
12772
574
            break;
12773
574
          case 0x21:
12774
76
              GETBYTE ();
12775
76
              switch (op[2] & 0x00)
12776
76
              {
12777
76
                case 0x00:
12778
76
                  goto op_semantics_102;
12779
0
                  break;
12780
76
              }
12781
0
            break;
12782
46
          case 0x22:
12783
46
              GETBYTE ();
12784
46
              switch (op[2] & 0x00)
12785
46
              {
12786
46
                case 0x00:
12787
46
                  goto op_semantics_102;
12788
0
                  break;
12789
46
              }
12790
0
            break;
12791
109
          case 0x24:
12792
109
              GETBYTE ();
12793
109
              switch (op[2] & 0x00)
12794
109
              {
12795
109
                case 0x00:
12796
109
                  goto op_semantics_102;
12797
0
                  break;
12798
109
              }
12799
0
            break;
12800
86
          case 0x25:
12801
86
              GETBYTE ();
12802
86
              switch (op[2] & 0x00)
12803
86
              {
12804
86
                case 0x00:
12805
86
                  goto op_semantics_102;
12806
0
                  break;
12807
86
              }
12808
0
            break;
12809
159
          case 0x26:
12810
159
              GETBYTE ();
12811
159
              switch (op[2] & 0x00)
12812
159
              {
12813
159
                case 0x00:
12814
159
                  goto op_semantics_102;
12815
0
                  break;
12816
159
              }
12817
0
            break;
12818
163
          case 0x27:
12819
163
              GETBYTE ();
12820
163
              switch (op[2] & 0x00)
12821
163
              {
12822
163
                case 0x00:
12823
163
                    {
12824
                      /** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */
12825
163
#line 1071 "rx-decode.opc"
12826
163
                      int rdst AU = (op[2] >> 4) & 0x0f;
12827
163
#line 1071 "rx-decode.opc"
12828
163
                      int rsrc AU = op[2] & 0x0f;
12829
163
                      if (trace)
12830
0
                        {
12831
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12832
0
                                 "/** 1111 1101 0010 0111 rdst rsrc movco %1, [%0] */",
12833
0
                                 op[0], op[1], op[2]);
12834
0
                          printf ("  rdst = 0x%x,", rdst);
12835
0
                          printf ("  rsrc = 0x%x\n", rsrc);
12836
0
                        }
12837
163
                      SYNTAX("movco %1, [%0]");
12838
163
#line 1071 "rx-decode.opc"
12839
163
                       ID(movco); SR(rsrc); DR(rdst); F_____;
12840
12841
163
                    }
12842
163
                  break;
12843
163
              }
12844
163
            break;
12845
279
          case 0x28:
12846
279
              GETBYTE ();
12847
279
              switch (op[2] & 0x00)
12848
279
              {
12849
279
                case 0x00:
12850
3.44k
                  op_semantics_103:
12851
3.44k
                    {
12852
                      /** 1111 1101 0010 1p sz rsrc rdst  mov%s %1, %0 */
12853
3.44k
#line 373 "rx-decode.opc"
12854
3.44k
                      int p AU = (op[1] >> 2) & 0x01;
12855
3.44k
#line 373 "rx-decode.opc"
12856
3.44k
                      int sz AU = op[1] & 0x03;
12857
3.44k
#line 373 "rx-decode.opc"
12858
3.44k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
12859
3.44k
#line 373 "rx-decode.opc"
12860
3.44k
                      int rdst AU = op[2] & 0x0f;
12861
3.44k
                      if (trace)
12862
0
                        {
12863
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12864
0
                                 "/** 1111 1101 0010 1p sz rsrc rdst  mov%s %1, %0 */",
12865
0
                                 op[0], op[1], op[2]);
12866
0
                          printf ("  p = 0x%x,", p);
12867
0
                          printf ("  sz = 0x%x,", sz);
12868
0
                          printf ("  rsrc = 0x%x,", rsrc);
12869
0
                          printf ("  rdst = 0x%x\n", rdst);
12870
0
                        }
12871
3.44k
                      SYNTAX("mov%s %1, %0");
12872
3.44k
#line 373 "rx-decode.opc"
12873
3.44k
                      ID(mov); sBWL (sz); DR(rdst); F_____;
12874
3.44k
                      OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875
12876
3.44k
                    }
12877
3.44k
                  break;
12878
279
              }
12879
3.44k
            break;
12880
3.44k
          case 0x29:
12881
84
              GETBYTE ();
12882
84
              switch (op[2] & 0x00)
12883
84
              {
12884
84
                case 0x00:
12885
84
                  goto op_semantics_103;
12886
0
                  break;
12887
84
              }
12888
0
            break;
12889
171
          case 0x2a:
12890
171
              GETBYTE ();
12891
171
              switch (op[2] & 0x00)
12892
171
              {
12893
171
                case 0x00:
12894
171
                  goto op_semantics_103;
12895
0
                  break;
12896
171
              }
12897
0
            break;
12898
219
          case 0x2c:
12899
219
              GETBYTE ();
12900
219
              switch (op[2] & 0x00)
12901
219
              {
12902
219
                case 0x00:
12903
219
                  goto op_semantics_103;
12904
0
                  break;
12905
219
              }
12906
0
            break;
12907
2.18k
          case 0x2d:
12908
2.18k
              GETBYTE ();
12909
2.18k
              switch (op[2] & 0x00)
12910
2.18k
              {
12911
2.18k
                case 0x00:
12912
2.18k
                  goto op_semantics_103;
12913
0
                  break;
12914
2.18k
              }
12915
0
            break;
12916
508
          case 0x2e:
12917
508
              GETBYTE ();
12918
508
              switch (op[2] & 0x00)
12919
508
              {
12920
508
                case 0x00:
12921
508
                  goto op_semantics_103;
12922
0
                  break;
12923
508
              }
12924
0
            break;
12925
196
          case 0x2f:
12926
196
              GETBYTE ();
12927
196
              switch (op[2] & 0x00)
12928
196
              {
12929
196
                case 0x00:
12930
196
                    {
12931
                      /** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */
12932
196
#line 1074 "rx-decode.opc"
12933
196
                      int rsrc AU = (op[2] >> 4) & 0x0f;
12934
196
#line 1074 "rx-decode.opc"
12935
196
                      int rdst AU = op[2] & 0x0f;
12936
196
                      if (trace)
12937
0
                        {
12938
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12939
0
                                 "/** 1111 1101 0010 1111 rsrc rdst movli [%1], %0 */",
12940
0
                                 op[0], op[1], op[2]);
12941
0
                          printf ("  rsrc = 0x%x,", rsrc);
12942
0
                          printf ("  rdst = 0x%x\n", rdst);
12943
0
                        }
12944
196
                      SYNTAX("movli [%1], %0");
12945
196
#line 1074 "rx-decode.opc"
12946
196
                       ID(movli); SR(rsrc); DR(rdst); F_____;
12947
12948
196
                    }
12949
196
                  break;
12950
196
              }
12951
196
            break;
12952
196
          case 0x38:
12953
27
              GETBYTE ();
12954
27
              switch (op[2] & 0x00)
12955
27
              {
12956
27
                case 0x00:
12957
1.42k
                  op_semantics_104:
12958
1.42k
                    {
12959
                      /** 1111 1101 0011 1p sz rsrc rdst  movu%s  %1, %0 */
12960
1.42k
#line 383 "rx-decode.opc"
12961
1.42k
                      int p AU = (op[1] >> 2) & 0x01;
12962
1.42k
#line 383 "rx-decode.opc"
12963
1.42k
                      int sz AU = op[1] & 0x03;
12964
1.42k
#line 383 "rx-decode.opc"
12965
1.42k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
12966
1.42k
#line 383 "rx-decode.opc"
12967
1.42k
                      int rdst AU = op[2] & 0x0f;
12968
1.42k
                      if (trace)
12969
0
                        {
12970
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12971
0
                                 "/** 1111 1101 0011 1p sz rsrc rdst  movu%s  %1, %0 */",
12972
0
                                 op[0], op[1], op[2]);
12973
0
                          printf ("  p = 0x%x,", p);
12974
0
                          printf ("  sz = 0x%x,", sz);
12975
0
                          printf ("  rsrc = 0x%x,", rsrc);
12976
0
                          printf ("  rdst = 0x%x\n", rdst);
12977
0
                        }
12978
1.42k
                      SYNTAX("movu%s  %1, %0");
12979
1.42k
#line 383 "rx-decode.opc"
12980
1.42k
                      ID(mov); uBW (sz); DR(rdst); F_____;
12981
1.42k
                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982
12983
                    /*----------------------------------------------------------------------*/
12984
                    /* PUSH/POP               */
12985
12986
1.42k
                    }
12987
1.42k
                  break;
12988
27
              }
12989
1.42k
            break;
12990
1.42k
          case 0x39:
12991
58
              GETBYTE ();
12992
58
              switch (op[2] & 0x00)
12993
58
              {
12994
58
                case 0x00:
12995
58
                  goto op_semantics_104;
12996
0
                  break;
12997
58
              }
12998
0
            break;
12999
673
          case 0x3a:
13000
673
              GETBYTE ();
13001
673
              switch (op[2] & 0x00)
13002
673
              {
13003
673
                case 0x00:
13004
673
                  goto op_semantics_104;
13005
0
                  break;
13006
673
              }
13007
0
            break;
13008
153
          case 0x3c:
13009
153
              GETBYTE ();
13010
153
              switch (op[2] & 0x00)
13011
153
              {
13012
153
                case 0x00:
13013
153
                  goto op_semantics_104;
13014
0
                  break;
13015
153
              }
13016
0
            break;
13017
218
          case 0x3d:
13018
218
              GETBYTE ();
13019
218
              switch (op[2] & 0x00)
13020
218
              {
13021
218
                case 0x00:
13022
218
                  goto op_semantics_104;
13023
0
                  break;
13024
218
              }
13025
0
            break;
13026
299
          case 0x3e:
13027
299
              GETBYTE ();
13028
299
              switch (op[2] & 0x00)
13029
299
              {
13030
299
                case 0x00:
13031
299
                  goto op_semantics_104;
13032
0
                  break;
13033
299
              }
13034
0
            break;
13035
157
          case 0x44:
13036
157
              GETBYTE ();
13037
157
              switch (op[2] & 0x00)
13038
157
              {
13039
157
                case 0x00:
13040
250
                  op_semantics_105:
13041
250
                    {
13042
                      /** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */
13043
250
#line 1095 "rx-decode.opc"
13044
250
                      int a AU = (op[1] >> 3) & 0x01;
13045
250
#line 1095 "rx-decode.opc"
13046
250
                      int srca AU = (op[2] >> 4) & 0x0f;
13047
250
#line 1095 "rx-decode.opc"
13048
250
                      int srcb AU = op[2] & 0x0f;
13049
250
                      if (trace)
13050
0
                        {
13051
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13052
0
                                 "/** 1111 1101 0100 a100 srca srcb msbhi %1, %2, %0 */",
13053
0
                                 op[0], op[1], op[2]);
13054
0
                          printf ("  a = 0x%x,", a);
13055
0
                          printf ("  srca = 0x%x,", srca);
13056
0
                          printf ("  srcb = 0x%x\n", srcb);
13057
0
                        }
13058
250
                      SYNTAX("msbhi %1, %2, %0");
13059
250
#line 1095 "rx-decode.opc"
13060
250
                      ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061
13062
250
                    }
13063
250
                  break;
13064
157
              }
13065
250
            break;
13066
250
          case 0x45:
13067
128
              GETBYTE ();
13068
128
              switch (op[2] & 0x00)
13069
128
              {
13070
128
                case 0x00:
13071
202
                  op_semantics_106:
13072
202
                    {
13073
                      /** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */
13074
202
#line 1101 "rx-decode.opc"
13075
202
                      int a AU = (op[1] >> 3) & 0x01;
13076
202
#line 1101 "rx-decode.opc"
13077
202
                      int srca AU = (op[2] >> 4) & 0x0f;
13078
202
#line 1101 "rx-decode.opc"
13079
202
                      int srcb AU = op[2] & 0x0f;
13080
202
                      if (trace)
13081
0
                        {
13082
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13083
0
                                 "/** 1111 1101 0100 a101 srca srcb msblo %1, %2, %0 */",
13084
0
                                 op[0], op[1], op[2]);
13085
0
                          printf ("  a = 0x%x,", a);
13086
0
                          printf ("  srca = 0x%x,", srca);
13087
0
                          printf ("  srcb = 0x%x\n", srcb);
13088
0
                        }
13089
202
                      SYNTAX("msblo %1, %2, %0");
13090
202
#line 1101 "rx-decode.opc"
13091
202
                      ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
13092
13093
202
                    }
13094
202
                  break;
13095
128
              }
13096
202
            break;
13097
466
          case 0x46:
13098
466
              GETBYTE ();
13099
466
              switch (op[2] & 0x00)
13100
466
              {
13101
466
                case 0x00:
13102
681
                  op_semantics_107:
13103
681
                    {
13104
                      /** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */
13105
681
#line 1098 "rx-decode.opc"
13106
681
                      int a AU = (op[1] >> 3) & 0x01;
13107
681
#line 1098 "rx-decode.opc"
13108
681
                      int srca AU = (op[2] >> 4) & 0x0f;
13109
681
#line 1098 "rx-decode.opc"
13110
681
                      int srcb AU = op[2] & 0x0f;
13111
681
                      if (trace)
13112
0
                        {
13113
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13114
0
                                 "/** 1111 1101 0100 a110 srca srcb msblh %1, %2, %0 */",
13115
0
                                 op[0], op[1], op[2]);
13116
0
                          printf ("  a = 0x%x,", a);
13117
0
                          printf ("  srca = 0x%x,", srca);
13118
0
                          printf ("  srcb = 0x%x\n", srcb);
13119
0
                        }
13120
681
                      SYNTAX("msblh %1, %2, %0");
13121
681
#line 1098 "rx-decode.opc"
13122
681
                      ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
13123
13124
681
                    }
13125
681
                  break;
13126
466
              }
13127
681
            break;
13128
681
          case 0x47:
13129
157
              GETBYTE ();
13130
157
              switch (op[2] & 0x00)
13131
157
              {
13132
157
                case 0x00:
13133
246
                  op_semantics_108:
13134
246
                    {
13135
                      /** 1111 1101 0100 a111 srca srcb   emsba %1, %2, %0 */
13136
246
#line 1086 "rx-decode.opc"
13137
246
                      int a AU = (op[1] >> 3) & 0x01;
13138
246
#line 1086 "rx-decode.opc"
13139
246
                      int srca AU = (op[2] >> 4) & 0x0f;
13140
246
#line 1086 "rx-decode.opc"
13141
246
                      int srcb AU = op[2] & 0x0f;
13142
246
                      if (trace)
13143
0
                        {
13144
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13145
0
                                 "/** 1111 1101 0100 a111 srca srcb   emsba %1, %2, %0 */",
13146
0
                                 op[0], op[1], op[2]);
13147
0
                          printf ("  a = 0x%x,", a);
13148
0
                          printf ("  srca = 0x%x,", srca);
13149
0
                          printf ("  srcb = 0x%x\n", srcb);
13150
0
                        }
13151
246
                      SYNTAX("emsba %1, %2, %0");
13152
246
#line 1086 "rx-decode.opc"
13153
246
                      ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
13154
13155
246
                    }
13156
246
                  break;
13157
157
              }
13158
246
            break;
13159
246
          case 0x4c:
13160
93
              GETBYTE ();
13161
93
              switch (op[2] & 0x00)
13162
93
              {
13163
93
                case 0x00:
13164
93
                  goto op_semantics_105;
13165
0
                  break;
13166
93
              }
13167
0
            break;
13168
74
          case 0x4d:
13169
74
              GETBYTE ();
13170
74
              switch (op[2] & 0x00)
13171
74
              {
13172
74
                case 0x00:
13173
74
                  goto op_semantics_106;
13174
0
                  break;
13175
74
              }
13176
0
            break;
13177
215
          case 0x4e:
13178
215
              GETBYTE ();
13179
215
              switch (op[2] & 0x00)
13180
215
              {
13181
215
                case 0x00:
13182
215
                  goto op_semantics_107;
13183
0
                  break;
13184
215
              }
13185
0
            break;
13186
89
          case 0x4f:
13187
89
              GETBYTE ();
13188
89
              switch (op[2] & 0x00)
13189
89
              {
13190
89
                case 0x00:
13191
89
                  goto op_semantics_108;
13192
0
                  break;
13193
89
              }
13194
0
            break;
13195
135
          case 0x60:
13196
135
              GETBYTE ();
13197
135
              switch (op[2] & 0x00)
13198
135
              {
13199
135
                case 0x00:
13200
135
                    {
13201
                      /** 1111 1101 0110 0000 rsrc rdst shlr  %2, %0 */
13202
135
#line 754 "rx-decode.opc"
13203
135
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13204
135
#line 754 "rx-decode.opc"
13205
135
                      int rdst AU = op[2] & 0x0f;
13206
135
                      if (trace)
13207
0
                        {
13208
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13209
0
                                 "/** 1111 1101 0110 0000 rsrc rdst shlr  %2, %0 */",
13210
0
                                 op[0], op[1], op[2]);
13211
0
                          printf ("  rsrc = 0x%x,", rsrc);
13212
0
                          printf ("  rdst = 0x%x\n", rdst);
13213
0
                        }
13214
135
                      SYNTAX("shlr  %2, %0");
13215
135
#line 754 "rx-decode.opc"
13216
135
                      ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217
13218
135
                    }
13219
135
                  break;
13220
135
              }
13221
135
            break;
13222
151
          case 0x61:
13223
151
              GETBYTE ();
13224
151
              switch (op[2] & 0x00)
13225
151
              {
13226
151
                case 0x00:
13227
151
                    {
13228
                      /** 1111 1101 0110 0001 rsrc rdst shar  %2, %0 */
13229
151
#line 744 "rx-decode.opc"
13230
151
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13231
151
#line 744 "rx-decode.opc"
13232
151
                      int rdst AU = op[2] & 0x0f;
13233
151
                      if (trace)
13234
0
                        {
13235
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13236
0
                                 "/** 1111 1101 0110 0001 rsrc rdst shar  %2, %0 */",
13237
0
                                 op[0], op[1], op[2]);
13238
0
                          printf ("  rsrc = 0x%x,", rsrc);
13239
0
                          printf ("  rdst = 0x%x\n", rdst);
13240
0
                        }
13241
151
                      SYNTAX("shar  %2, %0");
13242
151
#line 744 "rx-decode.opc"
13243
151
                      ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244
13245
151
                    }
13246
151
                  break;
13247
151
              }
13248
151
            break;
13249
151
          case 0x62:
13250
140
              GETBYTE ();
13251
140
              switch (op[2] & 0x00)
13252
140
              {
13253
140
                case 0x00:
13254
140
                    {
13255
                      /** 1111 1101 0110 0010 rsrc rdst shll  %2, %0 */
13256
140
#line 734 "rx-decode.opc"
13257
140
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13258
140
#line 734 "rx-decode.opc"
13259
140
                      int rdst AU = op[2] & 0x0f;
13260
140
                      if (trace)
13261
0
                        {
13262
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13263
0
                                 "/** 1111 1101 0110 0010 rsrc rdst shll  %2, %0 */",
13264
0
                                 op[0], op[1], op[2]);
13265
0
                          printf ("  rsrc = 0x%x,", rsrc);
13266
0
                          printf ("  rdst = 0x%x\n", rdst);
13267
0
                        }
13268
140
                      SYNTAX("shll  %2, %0");
13269
140
#line 734 "rx-decode.opc"
13270
140
                      ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
13271
13272
140
                    }
13273
140
                  break;
13274
140
              }
13275
140
            break;
13276
213
          case 0x64:
13277
213
              GETBYTE ();
13278
213
              switch (op[2] & 0x00)
13279
213
              {
13280
213
                case 0x00:
13281
213
                    {
13282
                      /** 1111 1101 0110 0100 rsrc rdst rotr  %1, %0 */
13283
213
#line 778 "rx-decode.opc"
13284
213
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13285
213
#line 778 "rx-decode.opc"
13286
213
                      int rdst AU = op[2] & 0x0f;
13287
213
                      if (trace)
13288
0
                        {
13289
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13290
0
                                 "/** 1111 1101 0110 0100 rsrc rdst rotr  %1, %0 */",
13291
0
                                 op[0], op[1], op[2]);
13292
0
                          printf ("  rsrc = 0x%x,", rsrc);
13293
0
                          printf ("  rdst = 0x%x\n", rdst);
13294
0
                        }
13295
213
                      SYNTAX("rotr  %1, %0");
13296
213
#line 778 "rx-decode.opc"
13297
213
                      ID(rotr); SR(rsrc); DR(rdst); F__SZC;
13298
13299
213
                    }
13300
213
                  break;
13301
213
              }
13302
213
            break;
13303
213
          case 0x65:
13304
127
              GETBYTE ();
13305
127
              switch (op[2] & 0x00)
13306
127
              {
13307
126
                case 0x00:
13308
126
                    {
13309
                      /** 1111 1101 0110 0101 rsrc rdst revw  %1, %0 */
13310
126
#line 781 "rx-decode.opc"
13311
126
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13312
126
#line 781 "rx-decode.opc"
13313
126
                      int rdst AU = op[2] & 0x0f;
13314
126
                      if (trace)
13315
0
                        {
13316
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13317
0
                                 "/** 1111 1101 0110 0101 rsrc rdst revw  %1, %0 */",
13318
0
                                 op[0], op[1], op[2]);
13319
0
                          printf ("  rsrc = 0x%x,", rsrc);
13320
0
                          printf ("  rdst = 0x%x\n", rdst);
13321
0
                        }
13322
126
                      SYNTAX("revw  %1, %0");
13323
126
#line 781 "rx-decode.opc"
13324
126
                      ID(revw); SR(rsrc); DR(rdst);
13325
13326
126
                    }
13327
126
                  break;
13328
127
              }
13329
126
            break;
13330
716
          case 0x66:
13331
716
              GETBYTE ();
13332
716
              switch (op[2] & 0x00)
13333
716
              {
13334
716
                case 0x00:
13335
716
                    {
13336
                      /** 1111 1101 0110 0110 rsrc rdst rotl  %1, %0 */
13337
716
#line 772 "rx-decode.opc"
13338
716
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13339
716
#line 772 "rx-decode.opc"
13340
716
                      int rdst AU = op[2] & 0x0f;
13341
716
                      if (trace)
13342
0
                        {
13343
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13344
0
                                 "/** 1111 1101 0110 0110 rsrc rdst rotl  %1, %0 */",
13345
0
                                 op[0], op[1], op[2]);
13346
0
                          printf ("  rsrc = 0x%x,", rsrc);
13347
0
                          printf ("  rdst = 0x%x\n", rdst);
13348
0
                        }
13349
716
                      SYNTAX("rotl  %1, %0");
13350
716
#line 772 "rx-decode.opc"
13351
716
                      ID(rotl); SR(rsrc); DR(rdst); F__SZC;
13352
13353
716
                    }
13354
716
                  break;
13355
716
              }
13356
716
            break;
13357
716
          case 0x67:
13358
171
              GETBYTE ();
13359
171
              switch (op[2] & 0x00)
13360
171
              {
13361
171
                case 0x00:
13362
171
                    {
13363
                      /** 1111 1101 0110 0111 rsrc rdst revl  %1, %0 */
13364
171
#line 784 "rx-decode.opc"
13365
171
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13366
171
#line 784 "rx-decode.opc"
13367
171
                      int rdst AU = op[2] & 0x0f;
13368
171
                      if (trace)
13369
0
                        {
13370
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13371
0
                                 "/** 1111 1101 0110 0111 rsrc rdst revl  %1, %0 */",
13372
0
                                 op[0], op[1], op[2]);
13373
0
                          printf ("  rsrc = 0x%x,", rsrc);
13374
0
                          printf ("  rdst = 0x%x\n", rdst);
13375
0
                        }
13376
171
                      SYNTAX("revl  %1, %0");
13377
171
#line 784 "rx-decode.opc"
13378
171
                      ID(revl); SR(rsrc); DR(rdst);
13379
13380
                    /*----------------------------------------------------------------------*/
13381
                    /* BRANCH               */
13382
13383
171
                    }
13384
171
                  break;
13385
171
              }
13386
171
            break;
13387
171
          case 0x68:
13388
35
              GETBYTE ();
13389
35
              switch (op[2] & 0x00)
13390
35
              {
13391
35
                case 0x00:
13392
388
                  op_semantics_109:
13393
388
                    {
13394
                      /** 1111 1101 0110 100c rsrc rdst mvtc  %1, %0 */
13395
388
#line 1035 "rx-decode.opc"
13396
388
                      int c AU = op[1] & 0x01;
13397
388
#line 1035 "rx-decode.opc"
13398
388
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13399
388
#line 1035 "rx-decode.opc"
13400
388
                      int rdst AU = op[2] & 0x0f;
13401
388
                      if (trace)
13402
0
                        {
13403
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13404
0
                                 "/** 1111 1101 0110 100c rsrc rdst mvtc  %1, %0 */",
13405
0
                                 op[0], op[1], op[2]);
13406
0
                          printf ("  c = 0x%x,", c);
13407
0
                          printf ("  rsrc = 0x%x,", rsrc);
13408
0
                          printf ("  rdst = 0x%x\n", rdst);
13409
0
                        }
13410
388
                      SYNTAX("mvtc  %1, %0");
13411
388
#line 1035 "rx-decode.opc"
13412
388
                      ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413
13414
388
                    }
13415
388
                  break;
13416
35
              }
13417
388
            break;
13418
388
          case 0x69:
13419
353
              GETBYTE ();
13420
353
              switch (op[2] & 0x00)
13421
353
              {
13422
353
                case 0x00:
13423
353
                  goto op_semantics_109;
13424
0
                  break;
13425
353
              }
13426
0
            break;
13427
235
          case 0x6a:
13428
235
              GETBYTE ();
13429
235
              switch (op[2] & 0x00)
13430
235
              {
13431
235
                case 0x00:
13432
321
                  op_semantics_110:
13433
321
                    {
13434
                      /** 1111 1101 0110 101s rsrc rdst mvfc  %1, %0 */
13435
321
#line 1038 "rx-decode.opc"
13436
321
                      int s AU = op[1] & 0x01;
13437
321
#line 1038 "rx-decode.opc"
13438
321
                      int rsrc AU = (op[2] >> 4) & 0x0f;
13439
321
#line 1038 "rx-decode.opc"
13440
321
                      int rdst AU = op[2] & 0x0f;
13441
321
                      if (trace)
13442
0
                        {
13443
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13444
0
                                 "/** 1111 1101 0110 101s rsrc rdst mvfc  %1, %0 */",
13445
0
                                 op[0], op[1], op[2]);
13446
0
                          printf ("  s = 0x%x,", s);
13447
0
                          printf ("  rsrc = 0x%x,", rsrc);
13448
0
                          printf ("  rdst = 0x%x\n", rdst);
13449
0
                        }
13450
321
                      SYNTAX("mvfc  %1, %0");
13451
321
#line 1038 "rx-decode.opc"
13452
321
                      ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453
13454
                    /*----------------------------------------------------------------------*/
13455
                    /* INTERRUPTS               */
13456
13457
321
                    }
13458
321
                  break;
13459
235
              }
13460
321
            break;
13461
321
          case 0x6b:
13462
86
              GETBYTE ();
13463
86
              switch (op[2] & 0x00)
13464
86
              {
13465
86
                case 0x00:
13466
86
                  goto op_semantics_110;
13467
0
                  break;
13468
86
              }
13469
0
            break;
13470
239
          case 0x6c:
13471
239
              GETBYTE ();
13472
239
              switch (op[2] & 0x00)
13473
239
              {
13474
239
                case 0x00:
13475
376
                  op_semantics_111:
13476
376
                    {
13477
                      /** 1111 1101 0110 110i mmmm rdst rotr  #%1, %0 */
13478
376
#line 775 "rx-decode.opc"
13479
376
                      int i AU = op[1] & 0x01;
13480
376
#line 775 "rx-decode.opc"
13481
376
                      int mmmm AU = (op[2] >> 4) & 0x0f;
13482
376
#line 775 "rx-decode.opc"
13483
376
                      int rdst AU = op[2] & 0x0f;
13484
376
                      if (trace)
13485
0
                        {
13486
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13487
0
                                 "/** 1111 1101 0110 110i mmmm rdst rotr  #%1, %0 */",
13488
0
                                 op[0], op[1], op[2]);
13489
0
                          printf ("  i = 0x%x,", i);
13490
0
                          printf ("  mmmm = 0x%x,", mmmm);
13491
0
                          printf ("  rdst = 0x%x\n", rdst);
13492
0
                        }
13493
376
                      SYNTAX("rotr  #%1, %0");
13494
376
#line 775 "rx-decode.opc"
13495
376
                      ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496
13497
376
                    }
13498
376
                  break;
13499
239
              }
13500
376
            break;
13501
376
          case 0x6d:
13502
137
              GETBYTE ();
13503
137
              switch (op[2] & 0x00)
13504
137
              {
13505
137
                case 0x00:
13506
137
                  goto op_semantics_111;
13507
0
                  break;
13508
137
              }
13509
0
            break;
13510
113
          case 0x6e:
13511
113
              GETBYTE ();
13512
113
              switch (op[2] & 0x00)
13513
113
              {
13514
113
                case 0x00:
13515
213
                  op_semantics_112:
13516
213
                    {
13517
                      /** 1111 1101 0110 111i mmmm rdst rotl  #%1, %0 */
13518
213
#line 769 "rx-decode.opc"
13519
213
                      int i AU = op[1] & 0x01;
13520
213
#line 769 "rx-decode.opc"
13521
213
                      int mmmm AU = (op[2] >> 4) & 0x0f;
13522
213
#line 769 "rx-decode.opc"
13523
213
                      int rdst AU = op[2] & 0x0f;
13524
213
                      if (trace)
13525
0
                        {
13526
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13527
0
                                 "/** 1111 1101 0110 111i mmmm rdst rotl  #%1, %0 */",
13528
0
                                 op[0], op[1], op[2]);
13529
0
                          printf ("  i = 0x%x,", i);
13530
0
                          printf ("  mmmm = 0x%x,", mmmm);
13531
0
                          printf ("  rdst = 0x%x\n", rdst);
13532
0
                        }
13533
213
                      SYNTAX("rotl  #%1, %0");
13534
213
#line 769 "rx-decode.opc"
13535
213
                      ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536
13537
213
                    }
13538
213
                  break;
13539
113
              }
13540
213
            break;
13541
213
          case 0x6f:
13542
100
              GETBYTE ();
13543
100
              switch (op[2] & 0x00)
13544
100
              {
13545
100
                case 0x00:
13546
100
                  goto op_semantics_112;
13547
0
                  break;
13548
100
              }
13549
0
            break;
13550
628
          case 0x70:
13551
628
              GETBYTE ();
13552
628
              switch (op[2] & 0xf0)
13553
628
              {
13554
34
                case 0x20:
13555
435
                  op_semantics_113:
13556
435
                    {
13557
                      /** 1111 1101 0111 im00 0010rdst  adc #%1, %0 */
13558
435
#line 513 "rx-decode.opc"
13559
435
                      int im AU = (op[1] >> 2) & 0x03;
13560
435
#line 513 "rx-decode.opc"
13561
435
                      int rdst AU = op[2] & 0x0f;
13562
435
                      if (trace)
13563
0
                        {
13564
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13565
0
                                 "/** 1111 1101 0111 im00 0010rdst  adc #%1, %0 */",
13566
0
                                 op[0], op[1], op[2]);
13567
0
                          printf ("  im = 0x%x,", im);
13568
0
                          printf ("  rdst = 0x%x\n", rdst);
13569
0
                        }
13570
435
                      SYNTAX("adc #%1, %0");
13571
435
#line 513 "rx-decode.opc"
13572
435
                      ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
13573
13574
435
                    }
13575
435
                  break;
13576
143
                case 0x40:
13577
232
                  op_semantics_114:
13578
232
                    {
13579
                      /** 1111 1101 0111 im00 0100rdst  max #%1, %0 */
13580
232
#line 595 "rx-decode.opc"
13581
232
                      int im AU = (op[1] >> 2) & 0x03;
13582
232
#line 595 "rx-decode.opc"
13583
232
                      int rdst AU = op[2] & 0x0f;
13584
232
                      if (trace)
13585
0
                        {
13586
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13587
0
                                 "/** 1111 1101 0111 im00 0100rdst  max #%1, %0 */",
13588
0
                                 op[0], op[1], op[2]);
13589
0
                          printf ("  im = 0x%x,", im);
13590
0
                          printf ("  rdst = 0x%x\n", rdst);
13591
0
                        }
13592
232
                      SYNTAX("max #%1, %0");
13593
232
#line 595 "rx-decode.opc"
13594
232
                      int val = IMMex (im);
13595
232
                      if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596
81
                        {
13597
81
                          ID (nop7);
13598
81
                          SYNTAX("nop\t; max\t#0x80000000, r0");
13599
81
                        }
13600
151
                      else
13601
151
                        {
13602
151
                          ID(max);
13603
151
                        }
13604
232
                      DR(rdst); SC(val);
13605
13606
232
                    }
13607
232
                  break;
13608
45
                case 0x50:
13609
284
                  op_semantics_115:
13610
284
                    {
13611
                      /** 1111 1101 0111 im00 0101rdst  min #%1, %0 */
13612
284
#line 625 "rx-decode.opc"
13613
284
                      int im AU = (op[1] >> 2) & 0x03;
13614
284
#line 625 "rx-decode.opc"
13615
284
                      int rdst AU = op[2] & 0x0f;
13616
284
                      if (trace)
13617
0
                        {
13618
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13619
0
                                 "/** 1111 1101 0111 im00 0101rdst  min #%1, %0 */",
13620
0
                                 op[0], op[1], op[2]);
13621
0
                          printf ("  im = 0x%x,", im);
13622
0
                          printf ("  rdst = 0x%x\n", rdst);
13623
0
                        }
13624
284
                      SYNTAX("min #%1, %0");
13625
284
#line 625 "rx-decode.opc"
13626
284
                      ID(min); DR(rdst); SC(IMMex(im));
13627
13628
284
                    }
13629
284
                  break;
13630
14
                case 0x60:
13631
92
                  op_semantics_116:
13632
92
                    {
13633
                      /** 1111 1101 0111 im00 0110rdst  emul  #%1, %0 */
13634
92
#line 683 "rx-decode.opc"
13635
92
                      int im AU = (op[1] >> 2) & 0x03;
13636
92
#line 683 "rx-decode.opc"
13637
92
                      int rdst AU = op[2] & 0x0f;
13638
92
                      if (trace)
13639
0
                        {
13640
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13641
0
                                 "/** 1111 1101 0111 im00 0110rdst  emul  #%1, %0 */",
13642
0
                                 op[0], op[1], op[2]);
13643
0
                          printf ("  im = 0x%x,", im);
13644
0
                          printf ("  rdst = 0x%x\n", rdst);
13645
0
                        }
13646
92
                      SYNTAX("emul  #%1, %0");
13647
92
#line 683 "rx-decode.opc"
13648
92
                      ID(emul); DR(rdst); SC(IMMex(im));
13649
13650
92
                    }
13651
92
                  break;
13652
65
                case 0x70:
13653
295
                  op_semantics_117:
13654
295
                    {
13655
                      /** 1111 1101 0111 im00 0111rdst  emulu #%1, %0 */
13656
295
#line 695 "rx-decode.opc"
13657
295
                      int im AU = (op[1] >> 2) & 0x03;
13658
295
#line 695 "rx-decode.opc"
13659
295
                      int rdst AU = op[2] & 0x0f;
13660
295
                      if (trace)
13661
0
                        {
13662
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13663
0
                                 "/** 1111 1101 0111 im00 0111rdst  emulu #%1, %0 */",
13664
0
                                 op[0], op[1], op[2]);
13665
0
                          printf ("  im = 0x%x,", im);
13666
0
                          printf ("  rdst = 0x%x\n", rdst);
13667
0
                        }
13668
295
                      SYNTAX("emulu #%1, %0");
13669
295
#line 695 "rx-decode.opc"
13670
295
                      ID(emulu); DR(rdst); SC(IMMex(im));
13671
13672
295
                    }
13673
295
                  break;
13674
32
                case 0x80:
13675
180
                  op_semantics_118:
13676
180
                    {
13677
                      /** 1111 1101 0111 im00 1000rdst  div #%1, %0 */
13678
180
#line 707 "rx-decode.opc"
13679
180
                      int im AU = (op[1] >> 2) & 0x03;
13680
180
#line 707 "rx-decode.opc"
13681
180
                      int rdst AU = op[2] & 0x0f;
13682
180
                      if (trace)
13683
0
                        {
13684
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13685
0
                                 "/** 1111 1101 0111 im00 1000rdst  div #%1, %0 */",
13686
0
                                 op[0], op[1], op[2]);
13687
0
                          printf ("  im = 0x%x,", im);
13688
0
                          printf ("  rdst = 0x%x\n", rdst);
13689
0
                        }
13690
180
                      SYNTAX("div #%1, %0");
13691
180
#line 707 "rx-decode.opc"
13692
180
                      ID(div); DR(rdst); SC(IMMex(im)); F_O___;
13693
13694
180
                    }
13695
180
                  break;
13696
17
                case 0x90:
13697
1.18k
                  op_semantics_119:
13698
1.18k
                    {
13699
                      /** 1111 1101 0111 im00 1001rdst  divu  #%1, %0 */
13700
1.18k
#line 719 "rx-decode.opc"
13701
1.18k
                      int im AU = (op[1] >> 2) & 0x03;
13702
1.18k
#line 719 "rx-decode.opc"
13703
1.18k
                      int rdst AU = op[2] & 0x0f;
13704
1.18k
                      if (trace)
13705
0
                        {
13706
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13707
0
                                 "/** 1111 1101 0111 im00 1001rdst  divu  #%1, %0 */",
13708
0
                                 op[0], op[1], op[2]);
13709
0
                          printf ("  im = 0x%x,", im);
13710
0
                          printf ("  rdst = 0x%x\n", rdst);
13711
0
                        }
13712
1.18k
                      SYNTAX("divu  #%1, %0");
13713
1.18k
#line 719 "rx-decode.opc"
13714
1.18k
                      ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
13715
13716
1.18k
                    }
13717
1.18k
                  break;
13718
55
                case 0xc0:
13719
261
                  op_semantics_120:
13720
261
                    {
13721
                      /** 1111 1101 0111 im00 1100rdst  tst #%1, %2 */
13722
261
#line 492 "rx-decode.opc"
13723
261
                      int im AU = (op[1] >> 2) & 0x03;
13724
261
#line 492 "rx-decode.opc"
13725
261
                      int rdst AU = op[2] & 0x0f;
13726
261
                      if (trace)
13727
0
                        {
13728
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13729
0
                                 "/** 1111 1101 0111 im00 1100rdst  tst #%1, %2 */",
13730
0
                                 op[0], op[1], op[2]);
13731
0
                          printf ("  im = 0x%x,", im);
13732
0
                          printf ("  rdst = 0x%x\n", rdst);
13733
0
                        }
13734
261
                      SYNTAX("tst #%1, %2");
13735
261
#line 492 "rx-decode.opc"
13736
261
                      ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
13737
13738
261
                    }
13739
261
                  break;
13740
10
                case 0xd0:
13741
219
                  op_semantics_121:
13742
219
                    {
13743
                      /** 1111 1101 0111 im00 1101rdst  xor #%1, %0 */
13744
219
#line 471 "rx-decode.opc"
13745
219
                      int im AU = (op[1] >> 2) & 0x03;
13746
219
#line 471 "rx-decode.opc"
13747
219
                      int rdst AU = op[2] & 0x0f;
13748
219
                      if (trace)
13749
0
                        {
13750
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13751
0
                                 "/** 1111 1101 0111 im00 1101rdst  xor #%1, %0 */",
13752
0
                                 op[0], op[1], op[2]);
13753
0
                          printf ("  im = 0x%x,", im);
13754
0
                          printf ("  rdst = 0x%x\n", rdst);
13755
0
                        }
13756
219
                      SYNTAX("xor #%1, %0");
13757
219
#line 471 "rx-decode.opc"
13758
219
                      ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
13759
13760
219
                    }
13761
219
                  break;
13762
4
                case 0xe0:
13763
95
                  op_semantics_122:
13764
95
                    {
13765
                      /** 1111 1101 0111 im00 1110rdst  stz #%1, %0 */
13766
95
#line 417 "rx-decode.opc"
13767
95
                      int im AU = (op[1] >> 2) & 0x03;
13768
95
#line 417 "rx-decode.opc"
13769
95
                      int rdst AU = op[2] & 0x0f;
13770
95
                      if (trace)
13771
0
                        {
13772
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13773
0
                                 "/** 1111 1101 0111 im00 1110rdst  stz #%1, %0 */",
13774
0
                                 op[0], op[1], op[2]);
13775
0
                          printf ("  im = 0x%x,", im);
13776
0
                          printf ("  rdst = 0x%x\n", rdst);
13777
0
                        }
13778
95
                      SYNTAX("stz #%1, %0");
13779
95
#line 417 "rx-decode.opc"
13780
95
                      ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
13781
13782
95
                    }
13783
95
                  break;
13784
38
                case 0xf0:
13785
563
                  op_semantics_123:
13786
563
                    {
13787
                      /** 1111 1101 0111 im00 1111rdst  stnz  #%1, %0 */
13788
563
#line 420 "rx-decode.opc"
13789
563
                      int im AU = (op[1] >> 2) & 0x03;
13790
563
#line 420 "rx-decode.opc"
13791
563
                      int rdst AU = op[2] & 0x0f;
13792
563
                      if (trace)
13793
0
                        {
13794
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13795
0
                                 "/** 1111 1101 0111 im00 1111rdst  stnz  #%1, %0 */",
13796
0
                                 op[0], op[1], op[2]);
13797
0
                          printf ("  im = 0x%x,", im);
13798
0
                          printf ("  rdst = 0x%x\n", rdst);
13799
0
                        }
13800
563
                      SYNTAX("stnz  #%1, %0");
13801
563
#line 420 "rx-decode.opc"
13802
563
                      ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803
13804
                    /*----------------------------------------------------------------------*/
13805
                    /* RTSD                 */
13806
13807
563
                    }
13808
563
                  break;
13809
171
                default: UNSUPPORTED(); break;
13810
628
              }
13811
4.01k
            break;
13812
4.01k
          case 0x72:
13813
1.76k
              GETBYTE ();
13814
1.76k
              switch (op[2] & 0xf0)
13815
1.76k
              {
13816
521
                case 0x00:
13817
521
                    {
13818
                      /** 1111 1101 0111 0010 0000 rdst fsub  #%1, %0 */
13819
521
#line 927 "rx-decode.opc"
13820
521
                      int rdst AU = op[2] & 0x0f;
13821
521
                      if (trace)
13822
0
                        {
13823
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13824
0
                                 "/** 1111 1101 0111 0010 0000 rdst fsub  #%1, %0 */",
13825
0
                                 op[0], op[1], op[2]);
13826
0
                          printf ("  rdst = 0x%x\n", rdst);
13827
0
                        }
13828
521
                      SYNTAX("fsub  #%1, %0");
13829
521
#line 927 "rx-decode.opc"
13830
521
                      ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831
13832
521
                    }
13833
521
                  break;
13834
325
                case 0x10:
13835
325
                    {
13836
                      /** 1111 1101 0111 0010 0001 rdst fcmp  #%1, %0 */
13837
325
#line 921 "rx-decode.opc"
13838
325
                      int rdst AU = op[2] & 0x0f;
13839
325
                      if (trace)
13840
0
                        {
13841
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13842
0
                                 "/** 1111 1101 0111 0010 0001 rdst fcmp  #%1, %0 */",
13843
0
                                 op[0], op[1], op[2]);
13844
0
                          printf ("  rdst = 0x%x\n", rdst);
13845
0
                        }
13846
325
                      SYNTAX("fcmp  #%1, %0");
13847
325
#line 921 "rx-decode.opc"
13848
325
                      ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
13849
13850
325
                    }
13851
325
                  break;
13852
233
                case 0x20:
13853
233
                    {
13854
                      /** 1111 1101 0111 0010 0010 rdst fadd  #%1, %0 */
13855
233
#line 915 "rx-decode.opc"
13856
233
                      int rdst AU = op[2] & 0x0f;
13857
233
                      if (trace)
13858
0
                        {
13859
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13860
0
                                 "/** 1111 1101 0111 0010 0010 rdst fadd  #%1, %0 */",
13861
0
                                 op[0], op[1], op[2]);
13862
0
                          printf ("  rdst = 0x%x\n", rdst);
13863
0
                        }
13864
233
                      SYNTAX("fadd  #%1, %0");
13865
233
#line 915 "rx-decode.opc"
13866
233
                      ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
13867
13868
233
                    }
13869
233
                  break;
13870
191
                case 0x30:
13871
191
                    {
13872
                      /** 1111 1101 0111 0010 0011 rdst fmul  #%1, %0 */
13873
191
#line 936 "rx-decode.opc"
13874
191
                      int rdst AU = op[2] & 0x0f;
13875
191
                      if (trace)
13876
0
                        {
13877
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13878
0
                                 "/** 1111 1101 0111 0010 0011 rdst fmul  #%1, %0 */",
13879
0
                                 op[0], op[1], op[2]);
13880
0
                          printf ("  rdst = 0x%x\n", rdst);
13881
0
                        }
13882
191
                      SYNTAX("fmul  #%1, %0");
13883
191
#line 936 "rx-decode.opc"
13884
191
                      ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
13885
13886
191
                    }
13887
191
                  break;
13888
346
                case 0x40:
13889
346
                    {
13890
                      /** 1111 1101 0111 0010 0100 rdst fdiv  #%1, %0 */
13891
346
#line 942 "rx-decode.opc"
13892
346
                      int rdst AU = op[2] & 0x0f;
13893
346
                      if (trace)
13894
0
                        {
13895
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13896
0
                                 "/** 1111 1101 0111 0010 0100 rdst fdiv  #%1, %0 */",
13897
0
                                 op[0], op[1], op[2]);
13898
0
                          printf ("  rdst = 0x%x\n", rdst);
13899
0
                        }
13900
346
                      SYNTAX("fdiv  #%1, %0");
13901
346
#line 942 "rx-decode.opc"
13902
346
                      ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
13903
13904
346
                    }
13905
346
                  break;
13906
144
                default: UNSUPPORTED(); break;
13907
1.76k
              }
13908
1.76k
            break;
13909
1.76k
          case 0x73:
13910
121
              GETBYTE ();
13911
121
              switch (op[2] & 0xe0)
13912
121
              {
13913
61
                case 0x00:
13914
2.70k
                  op_semantics_124:
13915
2.70k
                    {
13916
                      /** 1111 1101 0111 im11 000crdst  mvtc  #%1, %0 */
13917
2.70k
#line 1032 "rx-decode.opc"
13918
2.70k
                      int im AU = (op[1] >> 2) & 0x03;
13919
2.70k
#line 1032 "rx-decode.opc"
13920
2.70k
                      int crdst AU = op[2] & 0x1f;
13921
2.70k
                      if (trace)
13922
0
                        {
13923
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13924
0
                                 "/** 1111 1101 0111 im11 000crdst  mvtc  #%1, %0 */",
13925
0
                                 op[0], op[1], op[2]);
13926
0
                          printf ("  im = 0x%x,", im);
13927
0
                          printf ("  crdst = 0x%x\n", crdst);
13928
0
                        }
13929
2.70k
                      SYNTAX("mvtc  #%1, %0");
13930
2.70k
#line 1032 "rx-decode.opc"
13931
2.70k
                      ID(mov); SC(IMMex(im)); DR(crdst + 16);
13932
13933
2.70k
                    }
13934
2.70k
                  break;
13935
60
                default: UNSUPPORTED(); break;
13936
121
              }
13937
2.76k
            break;
13938
2.76k
          case 0x74:
13939
738
              GETBYTE ();
13940
738
              switch (op[2] & 0xf0)
13941
738
              {
13942
243
                case 0x20:
13943
243
                  goto op_semantics_113;
13944
0
                  break;
13945
34
                case 0x40:
13946
34
                  goto op_semantics_114;
13947
0
                  break;
13948
45
                case 0x50:
13949
45
                  goto op_semantics_115;
13950
0
                  break;
13951
40
                case 0x60:
13952
40
                  goto op_semantics_116;
13953
0
                  break;
13954
6
                case 0x70:
13955
6
                  goto op_semantics_117;
13956
0
                  break;
13957
11
                case 0x80:
13958
11
                  goto op_semantics_118;
13959
0
                  break;
13960
38
                case 0x90:
13961
38
                  goto op_semantics_119;
13962
0
                  break;
13963
12
                case 0xc0:
13964
12
                  goto op_semantics_120;
13965
0
                  break;
13966
174
                case 0xd0:
13967
174
                  goto op_semantics_121;
13968
0
                  break;
13969
23
                case 0xe0:
13970
23
                  goto op_semantics_122;
13971
0
                  break;
13972
59
                case 0xf0:
13973
59
                  goto op_semantics_123;
13974
0
                  break;
13975
49
                default: UNSUPPORTED(); break;
13976
738
              }
13977
49
            break;
13978
3.07k
          case 0x75:
13979
3.07k
              GETBYTE ();
13980
3.07k
              switch (op[2] & 0xff)
13981
3.07k
              {
13982
263
                case 0x80:
13983
263
                    GETBYTE ();
13984
263
                    switch (op[3] & 0x0f)
13985
263
                    {
13986
11
                      case 0x00:
13987
696
                        op_semantics_125:
13988
696
                          {
13989
                            /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l  %1, %0 */
13990
696
#line 1176 "rx-decode.opc"
13991
696
                            int rdst AU = op[2] & 0x0f;
13992
696
#line 1176 "rx-decode.opc"
13993
696
                            int rsrc AU = (op[3] >> 4) & 0x0f;
13994
696
                            if (trace)
13995
0
                              {
13996
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
13997
0
                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l  %1, %0 */",
13998
0
                                       op[0], op[1], op[2], op[3]);
13999
0
                                printf ("  rdst = 0x%x,", rdst);
14000
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14001
0
                              }
14002
696
                            SYNTAX("dmov.l  %1, %0");
14003
696
#line 1176 "rx-decode.opc"
14004
696
                            ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005
14006
696
                          }
14007
696
                        break;
14008
10
                      case 0x02:
14009
525
                        op_semantics_126:
14010
525
                          {
14011
                            /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l  %1, %0 */
14012
525
#line 1173 "rx-decode.opc"
14013
525
                            int rdst AU = op[2] & 0x0f;
14014
525
#line 1173 "rx-decode.opc"
14015
525
                            int rsrc AU = (op[3] >> 4) & 0x0f;
14016
525
                            if (trace)
14017
0
                              {
14018
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14019
0
                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l  %1, %0 */",
14020
0
                                       op[0], op[1], op[2], op[3]);
14021
0
                                printf ("  rdst = 0x%x,", rdst);
14022
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14023
0
                              }
14024
525
                            SYNTAX("dmov.l  %1, %0");
14025
525
#line 1173 "rx-decode.opc"
14026
525
                            ID(dmov); DR(rdst); SDRH(rsrc); F_____;
14027
14028
525
                          }
14029
525
                        break;
14030
214
                      case 0x04:
14031
707
                        op_semantics_127:
14032
707
                          {
14033
                            /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */
14034
707
#line 1226 "rx-decode.opc"
14035
707
                            int rdst AU = op[2] & 0x0f;
14036
707
#line 1226 "rx-decode.opc"
14037
707
                            int rsrc AU = (op[3] >> 4) & 0x0f;
14038
707
                            if (trace)
14039
0
                              {
14040
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14041
0
                                       "/** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc %1, %0 */",
14042
0
                                       op[0], op[1], op[2], op[3]);
14043
0
                                printf ("  rdst = 0x%x,", rdst);
14044
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14045
0
                              }
14046
707
                            SYNTAX("mvfdc %1, %0");
14047
707
#line 1226 "rx-decode.opc"
14048
707
                            ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049
14050
707
                          }
14051
707
                        break;
14052
28
                      default: UNSUPPORTED(); break;
14053
263
                    }
14054
1.95k
                  break;
14055
1.95k
                case 0x81:
14056
69
                    GETBYTE ();
14057
69
                    switch (op[3] & 0x0f)
14058
69
                    {
14059
9
                      case 0x00:
14060
9
                        goto op_semantics_125;
14061
0
                        break;
14062
9
                      case 0x02:
14063
9
                        goto op_semantics_126;
14064
0
                        break;
14065
0
                      case 0x04:
14066
0
                        goto op_semantics_127;
14067
0
                        break;
14068
51
                      default: UNSUPPORTED(); break;
14069
69
                    }
14070
51
                  break;
14071
354
                case 0x82:
14072
354
                    GETBYTE ();
14073
354
                    switch (op[3] & 0x0f)
14074
354
                    {
14075
175
                      case 0x00:
14076
175
                        goto op_semantics_125;
14077
0
                        break;
14078
1
                      case 0x02:
14079
1
                        goto op_semantics_126;
14080
0
                        break;
14081
95
                      case 0x04:
14082
95
                        goto op_semantics_127;
14083
0
                        break;
14084
83
                      default: UNSUPPORTED(); break;
14085
354
                    }
14086
83
                  break;
14087
209
                case 0x83:
14088
209
                    GETBYTE ();
14089
209
                    switch (op[3] & 0x0f)
14090
209
                    {
14091
26
                      case 0x00:
14092
26
                        goto op_semantics_125;
14093
0
                        break;
14094
125
                      case 0x02:
14095
125
                        goto op_semantics_126;
14096
0
                        break;
14097
41
                      case 0x04:
14098
41
                        goto op_semantics_127;
14099
0
                        break;
14100
17
                      default: UNSUPPORTED(); break;
14101
209
                    }
14102
17
                  break;
14103
17
                case 0x84:
14104
8
                    GETBYTE ();
14105
8
                    switch (op[3] & 0x0f)
14106
8
                    {
14107
0
                      case 0x00:
14108
0
                        goto op_semantics_125;
14109
0
                        break;
14110
4
                      case 0x02:
14111
4
                        goto op_semantics_126;
14112
0
                        break;
14113
0
                      case 0x04:
14114
0
                        goto op_semantics_127;
14115
0
                        break;
14116
4
                      default: UNSUPPORTED(); break;
14117
8
                    }
14118
4
                  break;
14119
27
                case 0x85:
14120
27
                    GETBYTE ();
14121
27
                    switch (op[3] & 0x0f)
14122
27
                    {
14123
18
                      case 0x00:
14124
18
                        goto op_semantics_125;
14125
0
                        break;
14126
0
                      case 0x02:
14127
0
                        goto op_semantics_126;
14128
0
                        break;
14129
9
                      case 0x04:
14130
9
                        goto op_semantics_127;
14131
0
                        break;
14132
0
                      default: UNSUPPORTED(); break;
14133
27
                    }
14134
0
                  break;
14135
178
                case 0x86:
14136
178
                    GETBYTE ();
14137
178
                    switch (op[3] & 0x0f)
14138
178
                    {
14139
72
                      case 0x00:
14140
72
                        goto op_semantics_125;
14141
0
                        break;
14142
17
                      case 0x02:
14143
17
                        goto op_semantics_126;
14144
0
                        break;
14145
23
                      case 0x04:
14146
23
                        goto op_semantics_127;
14147
0
                        break;
14148
66
                      default: UNSUPPORTED(); break;
14149
178
                    }
14150
66
                  break;
14151
382
                case 0x87:
14152
382
                    GETBYTE ();
14153
382
                    switch (op[3] & 0x0f)
14154
382
                    {
14155
71
                      case 0x00:
14156
71
                        goto op_semantics_125;
14157
0
                        break;
14158
72
                      case 0x02:
14159
72
                        goto op_semantics_126;
14160
0
                        break;
14161
180
                      case 0x04:
14162
180
                        goto op_semantics_127;
14163
0
                        break;
14164
59
                      default: UNSUPPORTED(); break;
14165
382
                    }
14166
59
                  break;
14167
83
                case 0x88:
14168
83
                    GETBYTE ();
14169
83
                    switch (op[3] & 0x0f)
14170
83
                    {
14171
44
                      case 0x00:
14172
44
                        goto op_semantics_125;
14173
0
                        break;
14174
0
                      case 0x02:
14175
0
                        goto op_semantics_126;
14176
0
                        break;
14177
6
                      case 0x04:
14178
6
                        goto op_semantics_127;
14179
0
                        break;
14180
33
                      default: UNSUPPORTED(); break;
14181
83
                    }
14182
33
                  break;
14183
52
                case 0x89:
14184
52
                    GETBYTE ();
14185
52
                    switch (op[3] & 0x0f)
14186
52
                    {
14187
2
                      case 0x00:
14188
2
                        goto op_semantics_125;
14189
0
                        break;
14190
18
                      case 0x02:
14191
18
                        goto op_semantics_126;
14192
0
                        break;
14193
12
                      case 0x04:
14194
12
                        goto op_semantics_127;
14195
0
                        break;
14196
20
                      default: UNSUPPORTED(); break;
14197
52
                    }
14198
20
                  break;
14199
132
                case 0x8a:
14200
132
                    GETBYTE ();
14201
132
                    switch (op[3] & 0x0f)
14202
132
                    {
14203
22
                      case 0x00:
14204
22
                        goto op_semantics_125;
14205
0
                        break;
14206
0
                      case 0x02:
14207
0
                        goto op_semantics_126;
14208
0
                        break;
14209
0
                      case 0x04:
14210
0
                        goto op_semantics_127;
14211
0
                        break;
14212
110
                      default: UNSUPPORTED(); break;
14213
132
                    }
14214
110
                  break;
14215
110
                case 0x8b:
14216
14
                    GETBYTE ();
14217
14
                    switch (op[3] & 0x0f)
14218
14
                    {
14219
10
                      case 0x00:
14220
10
                        goto op_semantics_125;
14221
0
                        break;
14222
0
                      case 0x02:
14223
0
                        goto op_semantics_126;
14224
0
                        break;
14225
0
                      case 0x04:
14226
0
                        goto op_semantics_127;
14227
0
                        break;
14228
4
                      default: UNSUPPORTED(); break;
14229
14
                    }
14230
4
                  break;
14231
343
                case 0x8c:
14232
343
                    GETBYTE ();
14233
343
                    switch (op[3] & 0x0f)
14234
343
                    {
14235
100
                      case 0x00:
14236
100
                        goto op_semantics_125;
14237
0
                        break;
14238
216
                      case 0x02:
14239
216
                        goto op_semantics_126;
14240
0
                        break;
14241
5
                      case 0x04:
14242
5
                        goto op_semantics_127;
14243
0
                        break;
14244
22
                      default: UNSUPPORTED(); break;
14245
343
                    }
14246
22
                  break;
14247
244
                case 0x8d:
14248
244
                    GETBYTE ();
14249
244
                    switch (op[3] & 0x0f)
14250
244
                    {
14251
14
                      case 0x00:
14252
14
                        goto op_semantics_125;
14253
0
                        break;
14254
32
                      case 0x02:
14255
32
                        goto op_semantics_126;
14256
0
                        break;
14257
15
                      case 0x04:
14258
15
                        goto op_semantics_127;
14259
0
                        break;
14260
183
                      default: UNSUPPORTED(); break;
14261
244
                    }
14262
183
                  break;
14263
183
                case 0x8e:
14264
173
                    GETBYTE ();
14265
173
                    switch (op[3] & 0x0f)
14266
173
                    {
14267
116
                      case 0x00:
14268
116
                        goto op_semantics_125;
14269
0
                        break;
14270
21
                      case 0x02:
14271
21
                        goto op_semantics_126;
14272
0
                        break;
14273
23
                      case 0x04:
14274
23
                        goto op_semantics_127;
14275
0
                        break;
14276
13
                      default: UNSUPPORTED(); break;
14277
173
                    }
14278
13
                  break;
14279
149
                case 0x8f:
14280
149
                    GETBYTE ();
14281
149
                    switch (op[3] & 0x0f)
14282
149
                    {
14283
6
                      case 0x00:
14284
6
                        goto op_semantics_125;
14285
0
                        break;
14286
0
                      case 0x02:
14287
0
                        goto op_semantics_126;
14288
0
                        break;
14289
84
                      case 0x04:
14290
84
                        goto op_semantics_127;
14291
0
                        break;
14292
59
                      default: UNSUPPORTED(); break;
14293
149
                    }
14294
59
                  break;
14295
399
                default: UNSUPPORTED(); break;
14296
3.07k
              }
14297
3.07k
            break;
14298
4.27k
          case 0x76:
14299
4.27k
              GETBYTE ();
14300
4.27k
              switch (op[2] & 0xff)
14301
4.27k
              {
14302
56
                case 0xc0:
14303
56
                    GETBYTE ();
14304
56
                    switch (op[3] & 0xff)
14305
56
                    {
14306
8
                      case 0x00:
14307
214
                        op_semantics_128:
14308
214
                          {
14309
                            /** 1111 1101 0111 0110 1100 rsrc 0000 0000   save  %1 */
14310
214
#line 1161 "rx-decode.opc"
14311
214
                            int rsrc AU = op[2] & 0x0f;
14312
214
                            if (trace)
14313
0
                              {
14314
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14315
0
                                       "/** 1111 1101 0111 0110 1100 rsrc 0000 0000   save  %1 */",
14316
0
                                       op[0], op[1], op[2], op[3]);
14317
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14318
0
                              }
14319
214
                            SYNTAX("save  %1");
14320
214
#line 1161 "rx-decode.opc"
14321
214
                            ID(save); SR(rsrc); F_____;
14322
14323
214
                          }
14324
214
                        break;
14325
48
                      default: UNSUPPORTED(); break;
14326
56
                    }
14327
262
                  break;
14328
262
                case 0xc1:
14329
3
                    GETBYTE ();
14330
3
                    switch (op[3] & 0xff)
14331
3
                    {
14332
0
                      case 0x00:
14333
0
                        goto op_semantics_128;
14334
0
                        break;
14335
3
                      default: UNSUPPORTED(); break;
14336
3
                    }
14337
3
                  break;
14338
20
                case 0xc2:
14339
20
                    GETBYTE ();
14340
20
                    switch (op[3] & 0xff)
14341
20
                    {
14342
4
                      case 0x00:
14343
4
                        goto op_semantics_128;
14344
0
                        break;
14345
16
                      default: UNSUPPORTED(); break;
14346
20
                    }
14347
16
                  break;
14348
179
                case 0xc3:
14349
179
                    GETBYTE ();
14350
179
                    switch (op[3] & 0xff)
14351
179
                    {
14352
1
                      case 0x00:
14353
1
                        goto op_semantics_128;
14354
0
                        break;
14355
178
                      default: UNSUPPORTED(); break;
14356
179
                    }
14357
178
                  break;
14358
178
                case 0xc4:
14359
9
                    GETBYTE ();
14360
9
                    switch (op[3] & 0xff)
14361
9
                    {
14362
0
                      case 0x00:
14363
0
                        goto op_semantics_128;
14364
0
                        break;
14365
9
                      default: UNSUPPORTED(); break;
14366
9
                    }
14367
9
                  break;
14368
37
                case 0xc5:
14369
37
                    GETBYTE ();
14370
37
                    switch (op[3] & 0xff)
14371
37
                    {
14372
9
                      case 0x00:
14373
9
                        goto op_semantics_128;
14374
0
                        break;
14375
28
                      default: UNSUPPORTED(); break;
14376
37
                    }
14377
28
                  break;
14378
28
                case 0xc6:
14379
6
                    GETBYTE ();
14380
6
                    switch (op[3] & 0xff)
14381
6
                    {
14382
6
                      case 0x00:
14383
6
                        goto op_semantics_128;
14384
0
                        break;
14385
0
                      default: UNSUPPORTED(); break;
14386
6
                    }
14387
0
                  break;
14388
142
                case 0xc7:
14389
142
                    GETBYTE ();
14390
142
                    switch (op[3] & 0xff)
14391
142
                    {
14392
0
                      case 0x00:
14393
0
                        goto op_semantics_128;
14394
0
                        break;
14395
142
                      default: UNSUPPORTED(); break;
14396
142
                    }
14397
142
                  break;
14398
142
                case 0xc8:
14399
1
                    GETBYTE ();
14400
1
                    switch (op[3] & 0xff)
14401
1
                    {
14402
0
                      case 0x00:
14403
0
                        goto op_semantics_128;
14404
0
                        break;
14405
1
                      default: UNSUPPORTED(); break;
14406
1
                    }
14407
1
                  break;
14408
51
                case 0xc9:
14409
51
                    GETBYTE ();
14410
51
                    switch (op[3] & 0xff)
14411
51
                    {
14412
0
                      case 0x00:
14413
0
                        goto op_semantics_128;
14414
0
                        break;
14415
51
                      default: UNSUPPORTED(); break;
14416
51
                    }
14417
51
                  break;
14418
51
                case 0xca:
14419
5
                    GETBYTE ();
14420
5
                    switch (op[3] & 0xff)
14421
5
                    {
14422
0
                      case 0x00:
14423
0
                        goto op_semantics_128;
14424
0
                        break;
14425
5
                      default: UNSUPPORTED(); break;
14426
5
                    }
14427
5
                  break;
14428
35
                case 0xcb:
14429
35
                    GETBYTE ();
14430
35
                    switch (op[3] & 0xff)
14431
35
                    {
14432
15
                      case 0x00:
14433
15
                        goto op_semantics_128;
14434
0
                        break;
14435
20
                      default: UNSUPPORTED(); break;
14436
35
                    }
14437
20
                  break;
14438
177
                case 0xcc:
14439
177
                    GETBYTE ();
14440
177
                    switch (op[3] & 0xff)
14441
177
                    {
14442
13
                      case 0x00:
14443
13
                        goto op_semantics_128;
14444
0
                        break;
14445
164
                      default: UNSUPPORTED(); break;
14446
177
                    }
14447
164
                  break;
14448
166
                case 0xcd:
14449
166
                    GETBYTE ();
14450
166
                    switch (op[3] & 0xff)
14451
166
                    {
14452
88
                      case 0x00:
14453
88
                        goto op_semantics_128;
14454
0
                        break;
14455
78
                      default: UNSUPPORTED(); break;
14456
166
                    }
14457
78
                  break;
14458
84
                case 0xce:
14459
84
                    GETBYTE ();
14460
84
                    switch (op[3] & 0xff)
14461
84
                    {
14462
70
                      case 0x00:
14463
70
                        goto op_semantics_128;
14464
0
                        break;
14465
14
                      default: UNSUPPORTED(); break;
14466
84
                    }
14467
14
                  break;
14468
82
                case 0xcf:
14469
82
                    GETBYTE ();
14470
82
                    switch (op[3] & 0xff)
14471
82
                    {
14472
0
                      case 0x00:
14473
0
                        goto op_semantics_128;
14474
0
                        break;
14475
82
                      default: UNSUPPORTED(); break;
14476
82
                    }
14477
82
                  break;
14478
82
                case 0xd0:
14479
36
                    GETBYTE ();
14480
36
                    switch (op[3] & 0xff)
14481
36
                    {
14482
0
                      case 0x00:
14483
369
                        op_semantics_129:
14484
369
                          {
14485
                            /** 1111 1101 0111 0110 1101 rsrc 0000 0000   rstr  %1 */
14486
369
#line 1155 "rx-decode.opc"
14487
369
                            int rsrc AU = op[2] & 0x0f;
14488
369
                            if (trace)
14489
0
                              {
14490
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14491
0
                                       "/** 1111 1101 0111 0110 1101 rsrc 0000 0000   rstr  %1 */",
14492
0
                                       op[0], op[1], op[2], op[3]);
14493
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14494
0
                              }
14495
369
                            SYNTAX("rstr  %1");
14496
369
#line 1155 "rx-decode.opc"
14497
369
                            ID(rstr); SR(rsrc); F_____;
14498
14499
369
                          }
14500
369
                        break;
14501
36
                      default: UNSUPPORTED(); break;
14502
36
                    }
14503
405
                  break;
14504
405
                case 0xd1:
14505
66
                    GETBYTE ();
14506
66
                    switch (op[3] & 0xff)
14507
66
                    {
14508
0
                      case 0x00:
14509
0
                        goto op_semantics_129;
14510
0
                        break;
14511
66
                      default: UNSUPPORTED(); break;
14512
66
                    }
14513
66
                  break;
14514
66
                case 0xd2:
14515
0
                    GETBYTE ();
14516
0
                    switch (op[3] & 0xff)
14517
0
                    {
14518
0
                      case 0x00:
14519
0
                        goto op_semantics_129;
14520
0
                        break;
14521
0
                      default: UNSUPPORTED(); break;
14522
0
                    }
14523
0
                  break;
14524
18
                case 0xd3:
14525
18
                    GETBYTE ();
14526
18
                    switch (op[3] & 0xff)
14527
18
                    {
14528
0
                      case 0x00:
14529
0
                        goto op_semantics_129;
14530
0
                        break;
14531
18
                      default: UNSUPPORTED(); break;
14532
18
                    }
14533
18
                  break;
14534
24
                case 0xd4:
14535
24
                    GETBYTE ();
14536
24
                    switch (op[3] & 0xff)
14537
24
                    {
14538
16
                      case 0x00:
14539
16
                        goto op_semantics_129;
14540
0
                        break;
14541
8
                      default: UNSUPPORTED(); break;
14542
24
                    }
14543
8
                  break;
14544
8
                case 0xd5:
14545
2
                    GETBYTE ();
14546
2
                    switch (op[3] & 0xff)
14547
2
                    {
14548
0
                      case 0x00:
14549
0
                        goto op_semantics_129;
14550
0
                        break;
14551
2
                      default: UNSUPPORTED(); break;
14552
2
                    }
14553
2
                  break;
14554
192
                case 0xd6:
14555
192
                    GETBYTE ();
14556
192
                    switch (op[3] & 0xff)
14557
192
                    {
14558
54
                      case 0x00:
14559
54
                        goto op_semantics_129;
14560
0
                        break;
14561
138
                      default: UNSUPPORTED(); break;
14562
192
                    }
14563
138
                  break;
14564
138
                case 0xd7:
14565
97
                    GETBYTE ();
14566
97
                    switch (op[3] & 0xff)
14567
97
                    {
14568
74
                      case 0x00:
14569
74
                        goto op_semantics_129;
14570
0
                        break;
14571
23
                      default: UNSUPPORTED(); break;
14572
97
                    }
14573
23
                  break;
14574
23
                case 0xd8:
14575
8
                    GETBYTE ();
14576
8
                    switch (op[3] & 0xff)
14577
8
                    {
14578
6
                      case 0x00:
14579
6
                        goto op_semantics_129;
14580
0
                        break;
14581
2
                      default: UNSUPPORTED(); break;
14582
8
                    }
14583
2
                  break;
14584
111
                case 0xd9:
14585
111
                    GETBYTE ();
14586
111
                    switch (op[3] & 0xff)
14587
111
                    {
14588
90
                      case 0x00:
14589
90
                        goto op_semantics_129;
14590
0
                        break;
14591
21
                      default: UNSUPPORTED(); break;
14592
111
                    }
14593
21
                  break;
14594
39
                case 0xda:
14595
39
                    GETBYTE ();
14596
39
                    switch (op[3] & 0xff)
14597
39
                    {
14598
39
                      case 0x00:
14599
39
                        goto op_semantics_129;
14600
0
                        break;
14601
0
                      default: UNSUPPORTED(); break;
14602
39
                    }
14603
0
                  break;
14604
19
                case 0xdb:
14605
19
                    GETBYTE ();
14606
19
                    switch (op[3] & 0xff)
14607
19
                    {
14608
0
                      case 0x00:
14609
0
                        goto op_semantics_129;
14610
0
                        break;
14611
19
                      default: UNSUPPORTED(); break;
14612
19
                    }
14613
19
                  break;
14614
577
                case 0xdc:
14615
577
                    GETBYTE ();
14616
577
                    switch (op[3] & 0xff)
14617
577
                    {
14618
1
                      case 0x00:
14619
1
                        goto op_semantics_129;
14620
0
                        break;
14621
576
                      default: UNSUPPORTED(); break;
14622
577
                    }
14623
576
                  break;
14624
576
                case 0xdd:
14625
197
                    GETBYTE ();
14626
197
                    switch (op[3] & 0xff)
14627
197
                    {
14628
63
                      case 0x00:
14629
63
                        goto op_semantics_129;
14630
0
                        break;
14631
134
                      default: UNSUPPORTED(); break;
14632
197
                    }
14633
134
                  break;
14634
327
                case 0xde:
14635
327
                    GETBYTE ();
14636
327
                    switch (op[3] & 0xff)
14637
327
                    {
14638
0
                      case 0x00:
14639
0
                        goto op_semantics_129;
14640
0
                        break;
14641
327
                      default: UNSUPPORTED(); break;
14642
327
                    }
14643
327
                  break;
14644
327
                case 0xdf:
14645
50
                    GETBYTE ();
14646
50
                    switch (op[3] & 0xff)
14647
50
                    {
14648
26
                      case 0x00:
14649
26
                        goto op_semantics_129;
14650
0
                        break;
14651
24
                      default: UNSUPPORTED(); break;
14652
50
                    }
14653
24
                  break;
14654
42
                case 0xe0:
14655
42
                    {
14656
                      /** 1111 1101 0111 0110 1110 0000 save  #%1 */
14657
42
                      if (trace)
14658
0
                        {
14659
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14660
0
                                 "/** 1111 1101 0111 0110 1110 0000 save  #%1 */",
14661
0
                                 op[0], op[1], op[2]);
14662
0
                        }
14663
42
                      SYNTAX("save  #%1");
14664
42
#line 1164 "rx-decode.opc"
14665
42
                      ID(save); SC(IMM(1)); F_____;
14666
14667
42
                    }
14668
42
                  break;
14669
70
                case 0xf0:
14670
70
                    {
14671
                      /** 1111 1101 0111 0110 1111 0000   rstr  #%1 */
14672
70
                      if (trace)
14673
0
                        {
14674
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14675
0
                                 "/** 1111 1101 0111 0110 1111 0000   rstr  #%1 */",
14676
0
                                 op[0], op[1], op[2]);
14677
0
                        }
14678
70
                      SYNTAX("rstr  #%1");
14679
70
#line 1158 "rx-decode.opc"
14680
70
                      ID(rstr); SC(IMM(1)); F_____;
14681
14682
70
                    }
14683
70
                  break;
14684
1.34k
                default: UNSUPPORTED(); break;
14685
4.27k
              }
14686
4.27k
            break;
14687
13.5k
          case 0x77:
14688
13.5k
              GETBYTE ();
14689
13.5k
              switch (op[2] & 0xff)
14690
13.5k
              {
14691
146
                case 0x00:
14692
253
                case 0x01:
14693
317
                case 0x02:
14694
368
                case 0x03:
14695
452
                case 0x04:
14696
458
                case 0x05:
14697
819
                case 0x06:
14698
845
                case 0x07:
14699
890
                case 0x08:
14700
944
                case 0x09:
14701
971
                case 0x0a:
14702
1.59k
                case 0x0b:
14703
1.65k
                case 0x0c:
14704
1.68k
                case 0x0d:
14705
1.68k
                case 0x0e:
14706
1.77k
                case 0x0f:
14707
1.92k
                case 0x10:
14708
1.93k
                case 0x11:
14709
1.95k
                case 0x12:
14710
1.96k
                case 0x13:
14711
1.99k
                case 0x14:
14712
1.99k
                case 0x15:
14713
2.18k
                case 0x16:
14714
2.20k
                case 0x17:
14715
2.20k
                case 0x18:
14716
2.41k
                case 0x19:
14717
2.42k
                case 0x1a:
14718
2.43k
                case 0x1b:
14719
2.45k
                case 0x1c:
14720
2.47k
                case 0x1d:
14721
2.50k
                case 0x1e:
14722
2.50k
                case 0x1f:
14723
2.50k
                  goto op_semantics_124;
14724
0
                  break;
14725
834
                case 0x80:
14726
834
                    GETBYTE ();
14727
834
                    switch (op[3] & 0x0f)
14728
834
                    {
14729
307
                      case 0x00:
14730
842
                        op_semantics_130:
14731
842
                          {
14732
                            /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l  %1, %0 */
14733
842
#line 1170 "rx-decode.opc"
14734
842
                            int rsrc AU = op[2] & 0x0f;
14735
842
#line 1170 "rx-decode.opc"
14736
842
                            int rdst AU = (op[3] >> 4) & 0x0f;
14737
842
                            if (trace)
14738
0
                              {
14739
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14740
0
                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l  %1, %0 */",
14741
0
                                       op[0], op[1], op[2], op[3]);
14742
0
                                printf ("  rsrc = 0x%x,", rsrc);
14743
0
                                printf ("  rdst = 0x%x\n", rdst);
14744
0
                              }
14745
842
                            SYNTAX("dmov.l  %1, %0");
14746
842
#line 1170 "rx-decode.opc"
14747
842
                            ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748
14749
842
                          }
14750
842
                        break;
14751
5
                      case 0x02:
14752
17
                      case 0x03:
14753
1.84k
                        op_semantics_131:
14754
1.84k
                          {
14755
                            /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s  %1, %0 */
14756
1.84k
#line 1167 "rx-decode.opc"
14757
1.84k
                            int rsrc AU = op[2] & 0x0f;
14758
1.84k
#line 1167 "rx-decode.opc"
14759
1.84k
                            int rdst AU = (op[3] >> 4) & 0x0f;
14760
1.84k
#line 1167 "rx-decode.opc"
14761
1.84k
                            int s AU = op[3] & 0x01;
14762
1.84k
                            if (trace)
14763
0
                              {
14764
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14765
0
                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s  %1, %0 */",
14766
0
                                       op[0], op[1], op[2], op[3]);
14767
0
                                printf ("  rsrc = 0x%x,", rsrc);
14768
0
                                printf ("  rdst = 0x%x,", rdst);
14769
0
                                printf ("  s = 0x%x\n", s);
14770
0
                              }
14771
1.84k
                            SYNTAX("dmov%s  %1, %0");
14772
1.84k
#line 1167 "rx-decode.opc"
14773
1.84k
                            ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774
14775
1.84k
                          }
14776
1.84k
                        break;
14777
3
                      case 0x04:
14778
2.26k
                        op_semantics_132:
14779
2.26k
                          {
14780
                            /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */
14781
2.26k
#line 1232 "rx-decode.opc"
14782
2.26k
                            int rdst AU = op[2] & 0x0f;
14783
2.26k
#line 1232 "rx-decode.opc"
14784
2.26k
                            int rsrc AU = (op[3] >> 4) & 0x0f;
14785
2.26k
                            if (trace)
14786
0
                              {
14787
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14788
0
                                       "/** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc %1, %0 */",
14789
0
                                       op[0], op[1], op[2], op[3]);
14790
0
                                printf ("  rdst = 0x%x,", rdst);
14791
0
                                printf ("  rsrc = 0x%x\n", rsrc);
14792
0
                              }
14793
2.26k
                            SYNTAX("mvtdc %1, %0");
14794
2.26k
#line 1232 "rx-decode.opc"
14795
2.26k
                            ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796
14797
2.26k
                          }
14798
2.26k
                        break;
14799
16
                      case 0x09:
14800
739
                        op_semantics_133:
14801
739
                          {
14802
                            /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod  %1, %0 */
14803
739
#line 1274 "rx-decode.opc"
14804
739
                            int rsrc AU = op[2] & 0x0f;
14805
739
#line 1274 "rx-decode.opc"
14806
739
                            int rdst AU = (op[3] >> 4) & 0x0f;
14807
739
                            if (trace)
14808
0
                              {
14809
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14810
0
                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod  %1, %0 */",
14811
0
                                       op[0], op[1], op[2], op[3]);
14812
0
                                printf ("  rsrc = 0x%x,", rsrc);
14813
0
                                printf ("  rdst = 0x%x\n", rdst);
14814
0
                              }
14815
739
                            SYNTAX("itod  %1, %0");
14816
739
#line 1274 "rx-decode.opc"
14817
739
                            ID(itod); DDR(rdst); SR(rsrc); F_____;
14818
14819
739
                          }
14820
739
                        break;
14821
325
                      case 0x0a:
14822
2.04k
                        op_semantics_134:
14823
2.04k
                          {
14824
                            /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod  %1, %0 */
14825
2.04k
#line 1271 "rx-decode.opc"
14826
2.04k
                            int rsrc AU = op[2] & 0x0f;
14827
2.04k
#line 1271 "rx-decode.opc"
14828
2.04k
                            int rdst AU = (op[3] >> 4) & 0x0f;
14829
2.04k
                            if (trace)
14830
0
                              {
14831
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14832
0
                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod  %1, %0 */",
14833
0
                                       op[0], op[1], op[2], op[3]);
14834
0
                                printf ("  rsrc = 0x%x,", rsrc);
14835
0
                                printf ("  rdst = 0x%x\n", rdst);
14836
0
                              }
14837
2.04k
                            SYNTAX("ftod  %1, %0");
14838
2.04k
#line 1271 "rx-decode.opc"
14839
2.04k
                            ID(ftod); DDR(rdst); SR(rsrc); F_____;
14840
14841
2.04k
                          }
14842
2.04k
                        break;
14843
2
                      case 0x0d:
14844
691
                        op_semantics_135:
14845
691
                          {
14846
                            /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod  %1, %0 */
14847
691
#line 1277 "rx-decode.opc"
14848
691
                            int rsrc AU = op[2] & 0x0f;
14849
691
#line 1277 "rx-decode.opc"
14850
691
                            int rdst AU = (op[3] >> 4) & 0x0f;
14851
691
                            if (trace)
14852
0
                              {
14853
0
                                printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14854
0
                                       "/** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod  %1, %0 */",
14855
0
                                       op[0], op[1], op[2], op[3]);
14856
0
                                printf ("  rsrc = 0x%x,", rsrc);
14857
0
                                printf ("  rdst = 0x%x\n", rdst);
14858
0
                              }
14859
691
                            SYNTAX("utod  %1, %0");
14860
691
#line 1277 "rx-decode.opc"
14861
691
                            ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
14862
14863
691
                          }
14864
691
                        break;
14865
163
                      default: UNSUPPORTED(); break;
14866
834
                    }
14867
8.57k
                  break;
14868
8.57k
                case 0x81:
14869
351
                    GETBYTE ();
14870
351
                    switch (op[3] & 0x0f)
14871
351
                    {
14872
1
                      case 0x00:
14873
1
                        goto op_semantics_130;
14874
0
                        break;
14875
9
                      case 0x02:
14876
161
                      case 0x03:
14877
161
                        goto op_semantics_131;
14878
0
                        break;
14879
3
                      case 0x04:
14880
3
                        goto op_semantics_132;
14881
0
                        break;
14882
19
                      case 0x09:
14883
19
                        goto op_semantics_133;
14884
0
                        break;
14885
135
                      case 0x0a:
14886
135
                        goto op_semantics_134;
14887
0
                        break;
14888
14
                      case 0x0d:
14889
14
                        goto op_semantics_135;
14890
0
                        break;
14891
16
                      default: UNSUPPORTED(); break;
14892
351
                    }
14893
16
                  break;
14894
1.60k
                case 0x82:
14895
1.60k
                    GETBYTE ();
14896
1.60k
                    switch (op[3] & 0x0f)
14897
1.60k
                    {
14898
12
                      case 0x00:
14899
12
                        goto op_semantics_130;
14900
0
                        break;
14901
62
                      case 0x02:
14902
95
                      case 0x03:
14903
95
                        goto op_semantics_131;
14904
0
                        break;
14905
1
                      case 0x04:
14906
1
                        goto op_semantics_132;
14907
0
                        break;
14908
5
                      case 0x09:
14909
5
                        goto op_semantics_133;
14910
0
                        break;
14911
877
                      case 0x0a:
14912
877
                        goto op_semantics_134;
14913
0
                        break;
14914
454
                      case 0x0d:
14915
454
                        goto op_semantics_135;
14916
0
                        break;
14917
159
                      default: UNSUPPORTED(); break;
14918
1.60k
                    }
14919
159
                  break;
14920
284
                case 0x83:
14921
284
                    GETBYTE ();
14922
284
                    switch (op[3] & 0x0f)
14923
284
                    {
14924
61
                      case 0x00:
14925
61
                        goto op_semantics_130;
14926
0
                        break;
14927
31
                      case 0x02:
14928
31
                      case 0x03:
14929
31
                        goto op_semantics_131;
14930
0
                        break;
14931
75
                      case 0x04:
14932
75
                        goto op_semantics_132;
14933
0
                        break;
14934
15
                      case 0x09:
14935
15
                        goto op_semantics_133;
14936
0
                        break;
14937
99
                      case 0x0a:
14938
99
                        goto op_semantics_134;
14939
0
                        break;
14940
2
                      case 0x0d:
14941
2
                        goto op_semantics_135;
14942
0
                        break;
14943
1
                      default: UNSUPPORTED(); break;
14944
284
                    }
14945
1
                  break;
14946
370
                case 0x84:
14947
370
                    GETBYTE ();
14948
370
                    switch (op[3] & 0x0f)
14949
370
                    {
14950
8
                      case 0x00:
14951
8
                        goto op_semantics_130;
14952
0
                        break;
14953
151
                      case 0x02:
14954
152
                      case 0x03:
14955
152
                        goto op_semantics_131;
14956
0
                        break;
14957
164
                      case 0x04:
14958
164
                        goto op_semantics_132;
14959
0
                        break;
14960
35
                      case 0x09:
14961
35
                        goto op_semantics_133;
14962
0
                        break;
14963
1
                      case 0x0a:
14964
1
                        goto op_semantics_134;
14965
0
                        break;
14966
0
                      case 0x0d:
14967
0
                        goto op_semantics_135;
14968
0
                        break;
14969
10
                      default: UNSUPPORTED(); break;
14970
370
                    }
14971
10
                  break;
14972
515
                case 0x85:
14973
515
                    GETBYTE ();
14974
515
                    switch (op[3] & 0x0f)
14975
515
                    {
14976
73
                      case 0x00:
14977
73
                        goto op_semantics_130;
14978
0
                        break;
14979
1
                      case 0x02:
14980
262
                      case 0x03:
14981
262
                        goto op_semantics_131;
14982
0
                        break;
14983
2
                      case 0x04:
14984
2
                        goto op_semantics_132;
14985
0
                        break;
14986
20
                      case 0x09:
14987
20
                        goto op_semantics_133;
14988
0
                        break;
14989
0
                      case 0x0a:
14990
0
                        goto op_semantics_134;
14991
0
                        break;
14992
0
                      case 0x0d:
14993
0
                        goto op_semantics_135;
14994
0
                        break;
14995
158
                      default: UNSUPPORTED(); break;
14996
515
                    }
14997
158
                  break;
14998
360
                case 0x86:
14999
360
                    GETBYTE ();
15000
360
                    switch (op[3] & 0x0f)
15001
360
                    {
15002
74
                      case 0x00:
15003
74
                        goto op_semantics_130;
15004
0
                        break;
15005
42
                      case 0x02:
15006
162
                      case 0x03:
15007
162
                        goto op_semantics_131;
15008
0
                        break;
15009
8
                      case 0x04:
15010
8
                        goto op_semantics_132;
15011
0
                        break;
15012
3
                      case 0x09:
15013
3
                        goto op_semantics_133;
15014
0
                        break;
15015
103
                      case 0x0a:
15016
103
                        goto op_semantics_134;
15017
0
                        break;
15018
1
                      case 0x0d:
15019
1
                        goto op_semantics_135;
15020
0
                        break;
15021
9
                      default: UNSUPPORTED(); break;
15022
360
                    }
15023
9
                  break;
15024
203
                case 0x87:
15025
203
                    GETBYTE ();
15026
203
                    switch (op[3] & 0x0f)
15027
203
                    {
15028
30
                      case 0x00:
15029
30
                        goto op_semantics_130;
15030
0
                        break;
15031
64
                      case 0x02:
15032
66
                      case 0x03:
15033
66
                        goto op_semantics_131;
15034
0
                        break;
15035
3
                      case 0x04:
15036
3
                        goto op_semantics_132;
15037
0
                        break;
15038
83
                      case 0x09:
15039
83
                        goto op_semantics_133;
15040
0
                        break;
15041
1
                      case 0x0a:
15042
1
                        goto op_semantics_134;
15043
0
                        break;
15044
1
                      case 0x0d:
15045
1
                        goto op_semantics_135;
15046
0
                        break;
15047
19
                      default: UNSUPPORTED(); break;
15048
203
                    }
15049
19
                  break;
15050
108
                case 0x88:
15051
108
                    GETBYTE ();
15052
108
                    switch (op[3] & 0x0f)
15053
108
                    {
15054
0
                      case 0x00:
15055
0
                        goto op_semantics_130;
15056
0
                        break;
15057
0
                      case 0x02:
15058
29
                      case 0x03:
15059
29
                        goto op_semantics_131;
15060
0
                        break;
15061
2
                      case 0x04:
15062
2
                        goto op_semantics_132;
15063
0
                        break;
15064
0
                      case 0x09:
15065
0
                        goto op_semantics_133;
15066
0
                        break;
15067
1
                      case 0x0a:
15068
1
                        goto op_semantics_134;
15069
0
                        break;
15070
0
                      case 0x0d:
15071
0
                        goto op_semantics_135;
15072
0
                        break;
15073
76
                      default: UNSUPPORTED(); break;
15074
108
                    }
15075
76
                  break;
15076
770
                case 0x89:
15077
770
                    GETBYTE ();
15078
770
                    switch (op[3] & 0x0f)
15079
770
                    {
15080
13
                      case 0x00:
15081
13
                        goto op_semantics_130;
15082
0
                        break;
15083
0
                      case 0x02:
15084
0
                      case 0x03:
15085
0
                        goto op_semantics_131;
15086
0
                        break;
15087
247
                      case 0x04:
15088
247
                        goto op_semantics_132;
15089
0
                        break;
15090
221
                      case 0x09:
15091
221
                        goto op_semantics_133;
15092
0
                        break;
15093
17
                      case 0x0a:
15094
17
                        goto op_semantics_134;
15095
0
                        break;
15096
17
                      case 0x0d:
15097
17
                        goto op_semantics_135;
15098
0
                        break;
15099
255
                      default: UNSUPPORTED(); break;
15100
770
                    }
15101
255
                  break;
15102
255
                case 0x8a:
15103
104
                    GETBYTE ();
15104
104
                    switch (op[3] & 0x0f)
15105
104
                    {
15106
21
                      case 0x00:
15107
21
                        goto op_semantics_130;
15108
0
                        break;
15109
6
                      case 0x02:
15110
31
                      case 0x03:
15111
31
                        goto op_semantics_131;
15112
0
                        break;
15113
0
                      case 0x04:
15114
0
                        goto op_semantics_132;
15115
0
                        break;
15116
0
                      case 0x09:
15117
0
                        goto op_semantics_133;
15118
0
                        break;
15119
23
                      case 0x0a:
15120
23
                        goto op_semantics_134;
15121
0
                        break;
15122
13
                      case 0x0d:
15123
13
                        goto op_semantics_135;
15124
0
                        break;
15125
16
                      default: UNSUPPORTED(); break;
15126
104
                    }
15127
16
                  break;
15128
2.10k
                case 0x8b:
15129
2.10k
                    GETBYTE ();
15130
2.10k
                    switch (op[3] & 0x0f)
15131
2.10k
                    {
15132
40
                      case 0x00:
15133
40
                        goto op_semantics_130;
15134
0
                        break;
15135
212
                      case 0x02:
15136
234
                      case 0x03:
15137
234
                        goto op_semantics_131;
15138
0
                        break;
15139
1.47k
                      case 0x04:
15140
1.47k
                        goto op_semantics_132;
15141
0
                        break;
15142
103
                      case 0x09:
15143
103
                        goto op_semantics_133;
15144
0
                        break;
15145
110
                      case 0x0a:
15146
110
                        goto op_semantics_134;
15147
0
                        break;
15148
8
                      case 0x0d:
15149
8
                        goto op_semantics_135;
15150
0
                        break;
15151
142
                      default: UNSUPPORTED(); break;
15152
2.10k
                    }
15153
142
                  break;
15154
189
                case 0x8c:
15155
189
                    GETBYTE ();
15156
189
                    switch (op[3] & 0x0f)
15157
189
                    {
15158
102
                      case 0x00:
15159
102
                        goto op_semantics_130;
15160
0
                        break;
15161
1
                      case 0x02:
15162
12
                      case 0x03:
15163
12
                        goto op_semantics_131;
15164
0
                        break;
15165
0
                      case 0x04:
15166
0
                        goto op_semantics_132;
15167
0
                        break;
15168
27
                      case 0x09:
15169
27
                        goto op_semantics_133;
15170
0
                        break;
15171
0
                      case 0x0a:
15172
0
                        goto op_semantics_134;
15173
0
                        break;
15174
15
                      case 0x0d:
15175
15
                        goto op_semantics_135;
15176
0
                        break;
15177
33
                      default: UNSUPPORTED(); break;
15178
189
                    }
15179
33
                  break;
15180
129
                case 0x8d:
15181
129
                    GETBYTE ();
15182
129
                    switch (op[3] & 0x0f)
15183
129
                    {
15184
10
                      case 0x00:
15185
10
                        goto op_semantics_130;
15186
0
                        break;
15187
16
                      case 0x02:
15188
17
                      case 0x03:
15189
17
                        goto op_semantics_131;
15190
0
                        break;
15191
13
                      case 0x04:
15192
13
                        goto op_semantics_132;
15193
0
                        break;
15194
0
                      case 0x09:
15195
0
                        goto op_semantics_133;
15196
0
                        break;
15197
14
                      case 0x0a:
15198
14
                        goto op_semantics_134;
15199
0
                        break;
15200
4
                      case 0x0d:
15201
4
                        goto op_semantics_135;
15202
0
                        break;
15203
69
                      default: UNSUPPORTED(); break;
15204
129
                    }
15205
69
                  break;
15206
1.78k
                case 0x8e:
15207
1.78k
                    GETBYTE ();
15208
1.78k
                    switch (op[3] & 0x0f)
15209
1.78k
                    {
15210
38
                      case 0x00:
15211
38
                        goto op_semantics_130;
15212
0
                        break;
15213
149
                      case 0x02:
15214
551
                      case 0x03:
15215
551
                        goto op_semantics_131;
15216
0
                        break;
15217
261
                      case 0x04:
15218
261
                        goto op_semantics_132;
15219
0
                        break;
15220
142
                      case 0x09:
15221
142
                        goto op_semantics_133;
15222
0
                        break;
15223
329
                      case 0x0a:
15224
329
                        goto op_semantics_134;
15225
0
                        break;
15226
155
                      case 0x0d:
15227
155
                        goto op_semantics_135;
15228
0
                        break;
15229
308
                      default: UNSUPPORTED(); break;
15230
1.78k
                    }
15231
308
                  break;
15232
308
                case 0x8f:
15233
160
                    GETBYTE ();
15234
160
                    switch (op[3] & 0x0f)
15235
160
                    {
15236
52
                      case 0x00:
15237
52
                        goto op_semantics_130;
15238
0
                        break;
15239
0
                      case 0x02:
15240
23
                      case 0x03:
15241
23
                        goto op_semantics_131;
15242
0
                        break;
15243
7
                      case 0x04:
15244
7
                        goto op_semantics_132;
15245
0
                        break;
15246
50
                      case 0x09:
15247
50
                        goto op_semantics_133;
15248
0
                        break;
15249
6
                      case 0x0a:
15250
6
                        goto op_semantics_134;
15251
0
                        break;
15252
5
                      case 0x0d:
15253
5
                        goto op_semantics_135;
15254
0
                        break;
15255
17
                      default: UNSUPPORTED(); break;
15256
160
                    }
15257
17
                  break;
15258
1.15k
                default: UNSUPPORTED(); break;
15259
13.5k
              }
15260
11.0k
            break;
15261
11.0k
          case 0x78:
15262
840
              GETBYTE ();
15263
840
              switch (op[2] & 0xf0)
15264
840
              {
15265
42
                case 0x20:
15266
42
                  goto op_semantics_113;
15267
0
                  break;
15268
33
                case 0x40:
15269
33
                  goto op_semantics_114;
15270
0
                  break;
15271
59
                case 0x50:
15272
59
                  goto op_semantics_115;
15273
0
                  break;
15274
16
                case 0x60:
15275
16
                  goto op_semantics_116;
15276
0
                  break;
15277
127
                case 0x70:
15278
127
                  goto op_semantics_117;
15279
0
                  break;
15280
82
                case 0x80:
15281
82
                  goto op_semantics_118;
15282
0
                  break;
15283
39
                case 0x90:
15284
39
                  goto op_semantics_119;
15285
0
                  break;
15286
6
                case 0xc0:
15287
6
                  goto op_semantics_120;
15288
0
                  break;
15289
4
                case 0xd0:
15290
4
                  goto op_semantics_121;
15291
0
                  break;
15292
1
                case 0xe0:
15293
1
                  goto op_semantics_122;
15294
0
                  break;
15295
12
                case 0xf0:
15296
12
                  goto op_semantics_123;
15297
0
                  break;
15298
419
                default: UNSUPPORTED(); break;
15299
840
              }
15300
419
            break;
15301
451
          case 0x7b:
15302
451
              GETBYTE ();
15303
451
              switch (op[2] & 0xe0)
15304
451
              {
15305
4
                case 0x00:
15306
4
                  goto op_semantics_124;
15307
0
                  break;
15308
446
                default: UNSUPPORTED(); break;
15309
451
              }
15310
446
            break;
15311
2.87k
          case 0x7c:
15312
2.87k
              GETBYTE ();
15313
2.87k
              switch (op[2] & 0xf0)
15314
2.87k
              {
15315
116
                case 0x20:
15316
116
                  goto op_semantics_113;
15317
0
                  break;
15318
22
                case 0x40:
15319
22
                  goto op_semantics_114;
15320
0
                  break;
15321
135
                case 0x50:
15322
135
                  goto op_semantics_115;
15323
0
                  break;
15324
22
                case 0x60:
15325
22
                  goto op_semantics_116;
15326
0
                  break;
15327
97
                case 0x70:
15328
97
                  goto op_semantics_117;
15329
0
                  break;
15330
55
                case 0x80:
15331
55
                  goto op_semantics_118;
15332
0
                  break;
15333
1.09k
                case 0x90:
15334
1.09k
                  goto op_semantics_119;
15335
0
                  break;
15336
188
                case 0xc0:
15337
188
                  goto op_semantics_120;
15338
0
                  break;
15339
31
                case 0xd0:
15340
31
                  goto op_semantics_121;
15341
0
                  break;
15342
67
                case 0xe0:
15343
67
                  goto op_semantics_122;
15344
0
                  break;
15345
454
                case 0xf0:
15346
454
                  goto op_semantics_123;
15347
0
                  break;
15348
594
                default: UNSUPPORTED(); break;
15349
2.87k
              }
15350
594
            break;
15351
684
          case 0x7f:
15352
684
              GETBYTE ();
15353
684
              switch (op[2] & 0xe0)
15354
684
              {
15355
142
                case 0x00:
15356
142
                  goto op_semantics_124;
15357
0
                  break;
15358
542
                default: UNSUPPORTED(); break;
15359
684
              }
15360
542
            break;
15361
675
          case 0x80:
15362
675
              GETBYTE ();
15363
675
              switch (op[2] & 0x00)
15364
675
              {
15365
675
                case 0x00:
15366
7.68k
                  op_semantics_136:
15367
7.68k
                    {
15368
                      /** 1111 1101 100immmm rsrc rdst  shlr  #%2, %1, %0 */
15369
7.68k
#line 757 "rx-decode.opc"
15370
7.68k
                      int immmm AU = op[1] & 0x1f;
15371
7.68k
#line 757 "rx-decode.opc"
15372
7.68k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
15373
7.68k
#line 757 "rx-decode.opc"
15374
7.68k
                      int rdst AU = op[2] & 0x0f;
15375
7.68k
                      if (trace)
15376
0
                        {
15377
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15378
0
                                 "/** 1111 1101 100immmm rsrc rdst  shlr  #%2, %1, %0 */",
15379
0
                                 op[0], op[1], op[2]);
15380
0
                          printf ("  immmm = 0x%x,", immmm);
15381
0
                          printf ("  rsrc = 0x%x,", rsrc);
15382
0
                          printf ("  rdst = 0x%x\n", rdst);
15383
0
                        }
15384
7.68k
                      SYNTAX("shlr  #%2, %1, %0");
15385
7.68k
#line 757 "rx-decode.opc"
15386
7.68k
                      ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
15387
15388
                    /*----------------------------------------------------------------------*/
15389
                    /* ROTATE               */
15390
15391
7.68k
                    }
15392
7.68k
                  break;
15393
675
              }
15394
7.68k
            break;
15395
7.68k
          case 0x81:
15396
146
              GETBYTE ();
15397
146
              switch (op[2] & 0x00)
15398
146
              {
15399
146
                case 0x00:
15400
146
                  goto op_semantics_136;
15401
0
                  break;
15402
146
              }
15403
0
            break;
15404
166
          case 0x82:
15405
166
              GETBYTE ();
15406
166
              switch (op[2] & 0x00)
15407
166
              {
15408
166
                case 0x00:
15409
166
                  goto op_semantics_136;
15410
0
                  break;
15411
166
              }
15412
0
            break;
15413
162
          case 0x83:
15414
162
              GETBYTE ();
15415
162
              switch (op[2] & 0x00)
15416
162
              {
15417
162
                case 0x00:
15418
162
                  goto op_semantics_136;
15419
0
                  break;
15420
162
              }
15421
0
            break;
15422
63
          case 0x84:
15423
63
              GETBYTE ();
15424
63
              switch (op[2] & 0x00)
15425
63
              {
15426
63
                case 0x00:
15427
63
                  goto op_semantics_136;
15428
0
                  break;
15429
63
              }
15430
0
            break;
15431
72
          case 0x85:
15432
72
              GETBYTE ();
15433
72
              switch (op[2] & 0x00)
15434
72
              {
15435
72
                case 0x00:
15436
72
                  goto op_semantics_136;
15437
0
                  break;
15438
72
              }
15439
0
            break;
15440
70
          case 0x86:
15441
70
              GETBYTE ();
15442
70
              switch (op[2] & 0x00)
15443
70
              {
15444
70
                case 0x00:
15445
70
                  goto op_semantics_136;
15446
0
                  break;
15447
70
              }
15448
0
            break;
15449
60
          case 0x87:
15450
60
              GETBYTE ();
15451
60
              switch (op[2] & 0x00)
15452
60
              {
15453
60
                case 0x00:
15454
60
                  goto op_semantics_136;
15455
0
                  break;
15456
60
              }
15457
0
            break;
15458
115
          case 0x88:
15459
115
              GETBYTE ();
15460
115
              switch (op[2] & 0x00)
15461
115
              {
15462
115
                case 0x00:
15463
115
                  goto op_semantics_136;
15464
0
                  break;
15465
115
              }
15466
0
            break;
15467
1.56k
          case 0x89:
15468
1.56k
              GETBYTE ();
15469
1.56k
              switch (op[2] & 0x00)
15470
1.56k
              {
15471
1.56k
                case 0x00:
15472
1.56k
                  goto op_semantics_136;
15473
0
                  break;
15474
1.56k
              }
15475
0
            break;
15476
263
          case 0x8a:
15477
263
              GETBYTE ();
15478
263
              switch (op[2] & 0x00)
15479
263
              {
15480
263
                case 0x00:
15481
263
                  goto op_semantics_136;
15482
0
                  break;
15483
263
              }
15484
0
            break;
15485
302
          case 0x8b:
15486
302
              GETBYTE ();
15487
302
              switch (op[2] & 0x00)
15488
302
              {
15489
302
                case 0x00:
15490
302
                  goto op_semantics_136;
15491
0
                  break;
15492
302
              }
15493
0
            break;
15494
139
          case 0x8c:
15495
139
              GETBYTE ();
15496
139
              switch (op[2] & 0x00)
15497
139
              {
15498
139
                case 0x00:
15499
139
                  goto op_semantics_136;
15500
0
                  break;
15501
139
              }
15502
0
            break;
15503
188
          case 0x8d:
15504
188
              GETBYTE ();
15505
188
              switch (op[2] & 0x00)
15506
188
              {
15507
188
                case 0x00:
15508
188
                  goto op_semantics_136;
15509
0
                  break;
15510
188
              }
15511
0
            break;
15512
259
          case 0x8e:
15513
259
              GETBYTE ();
15514
259
              switch (op[2] & 0x00)
15515
259
              {
15516
259
                case 0x00:
15517
259
                  goto op_semantics_136;
15518
0
                  break;
15519
259
              }
15520
0
            break;
15521
91
          case 0x8f:
15522
91
              GETBYTE ();
15523
91
              switch (op[2] & 0x00)
15524
91
              {
15525
91
                case 0x00:
15526
91
                  goto op_semantics_136;
15527
0
                  break;
15528
91
              }
15529
0
            break;
15530
449
          case 0x90:
15531
449
              GETBYTE ();
15532
449
              switch (op[2] & 0x00)
15533
449
              {
15534
449
                case 0x00:
15535
449
                  goto op_semantics_136;
15536
0
                  break;
15537
449
              }
15538
0
            break;
15539
5
          case 0x91:
15540
5
              GETBYTE ();
15541
5
              switch (op[2] & 0x00)
15542
5
              {
15543
5
                case 0x00:
15544
5
                  goto op_semantics_136;
15545
0
                  break;
15546
5
              }
15547
0
            break;
15548
251
          case 0x92:
15549
251
              GETBYTE ();
15550
251
              switch (op[2] & 0x00)
15551
251
              {
15552
250
                case 0x00:
15553
250
                  goto op_semantics_136;
15554
0
                  break;
15555
251
              }
15556
0
            break;
15557
252
          case 0x93:
15558
252
              GETBYTE ();
15559
252
              switch (op[2] & 0x00)
15560
252
              {
15561
252
                case 0x00:
15562
252
                  goto op_semantics_136;
15563
0
                  break;
15564
252
              }
15565
0
            break;
15566
85
          case 0x94:
15567
85
              GETBYTE ();
15568
85
              switch (op[2] & 0x00)
15569
85
              {
15570
85
                case 0x00:
15571
85
                  goto op_semantics_136;
15572
0
                  break;
15573
85
              }
15574
0
            break;
15575
255
          case 0x95:
15576
255
              GETBYTE ();
15577
255
              switch (op[2] & 0x00)
15578
255
              {
15579
253
                case 0x00:
15580
253
                  goto op_semantics_136;
15581
0
                  break;
15582
255
              }
15583
0
            break;
15584
191
          case 0x96:
15585
191
              GETBYTE ();
15586
191
              switch (op[2] & 0x00)
15587
191
              {
15588
191
                case 0x00:
15589
191
                  goto op_semantics_136;
15590
0
                  break;
15591
191
              }
15592
0
            break;
15593
133
          case 0x97:
15594
133
              GETBYTE ();
15595
133
              switch (op[2] & 0x00)
15596
133
              {
15597
133
                case 0x00:
15598
133
                  goto op_semantics_136;
15599
0
                  break;
15600
133
              }
15601
0
            break;
15602
62
          case 0x98:
15603
62
              GETBYTE ();
15604
62
              switch (op[2] & 0x00)
15605
62
              {
15606
62
                case 0x00:
15607
62
                  goto op_semantics_136;
15608
0
                  break;
15609
62
              }
15610
0
            break;
15611
29
          case 0x99:
15612
29
              GETBYTE ();
15613
29
              switch (op[2] & 0x00)
15614
29
              {
15615
29
                case 0x00:
15616
29
                  goto op_semantics_136;
15617
0
                  break;
15618
29
              }
15619
0
            break;
15620
386
          case 0x9a:
15621
386
              GETBYTE ();
15622
386
              switch (op[2] & 0x00)
15623
386
              {
15624
386
                case 0x00:
15625
386
                  goto op_semantics_136;
15626
0
                  break;
15627
386
              }
15628
0
            break;
15629
64
          case 0x9b:
15630
64
              GETBYTE ();
15631
64
              switch (op[2] & 0x00)
15632
64
              {
15633
64
                case 0x00:
15634
64
                  goto op_semantics_136;
15635
0
                  break;
15636
64
              }
15637
0
            break;
15638
86
          case 0x9c:
15639
86
              GETBYTE ();
15640
86
              switch (op[2] & 0x00)
15641
86
              {
15642
86
                case 0x00:
15643
86
                  goto op_semantics_136;
15644
0
                  break;
15645
86
              }
15646
0
            break;
15647
54
          case 0x9d:
15648
54
              GETBYTE ();
15649
54
              switch (op[2] & 0x00)
15650
54
              {
15651
54
                case 0x00:
15652
54
                  goto op_semantics_136;
15653
0
                  break;
15654
54
              }
15655
0
            break;
15656
51
          case 0x9e:
15657
51
              GETBYTE ();
15658
51
              switch (op[2] & 0x00)
15659
51
              {
15660
51
                case 0x00:
15661
51
                  goto op_semantics_136;
15662
0
                  break;
15663
51
              }
15664
0
            break;
15665
997
          case 0x9f:
15666
997
              GETBYTE ();
15667
997
              switch (op[2] & 0x00)
15668
997
              {
15669
997
                case 0x00:
15670
997
                  goto op_semantics_136;
15671
0
                  break;
15672
997
              }
15673
0
            break;
15674
36
          case 0xa0:
15675
36
              GETBYTE ();
15676
36
              switch (op[2] & 0x00)
15677
36
              {
15678
36
                case 0x00:
15679
3.97k
                  op_semantics_137:
15680
3.97k
                    {
15681
                      /** 1111 1101 101immmm rsrc rdst  shar  #%2, %1, %0 */
15682
3.97k
#line 747 "rx-decode.opc"
15683
3.97k
                      int immmm AU = op[1] & 0x1f;
15684
3.97k
#line 747 "rx-decode.opc"
15685
3.97k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
15686
3.97k
#line 747 "rx-decode.opc"
15687
3.97k
                      int rdst AU = op[2] & 0x0f;
15688
3.97k
                      if (trace)
15689
0
                        {
15690
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15691
0
                                 "/** 1111 1101 101immmm rsrc rdst  shar  #%2, %1, %0 */",
15692
0
                                 op[0], op[1], op[2]);
15693
0
                          printf ("  immmm = 0x%x,", immmm);
15694
0
                          printf ("  rsrc = 0x%x,", rsrc);
15695
0
                          printf ("  rdst = 0x%x\n", rdst);
15696
0
                        }
15697
3.97k
                      SYNTAX("shar  #%2, %1, %0");
15698
3.97k
#line 747 "rx-decode.opc"
15699
3.97k
                      ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
15700
15701
15702
3.97k
                    }
15703
3.97k
                  break;
15704
36
              }
15705
3.97k
            break;
15706
3.97k
          case 0xa1:
15707
53
              GETBYTE ();
15708
53
              switch (op[2] & 0x00)
15709
53
              {
15710
53
                case 0x00:
15711
53
                  goto op_semantics_137;
15712
0
                  break;
15713
53
              }
15714
0
            break;
15715
52
          case 0xa2:
15716
52
              GETBYTE ();
15717
52
              switch (op[2] & 0x00)
15718
52
              {
15719
52
                case 0x00:
15720
52
                  goto op_semantics_137;
15721
0
                  break;
15722
52
              }
15723
0
            break;
15724
178
          case 0xa3:
15725
178
              GETBYTE ();
15726
178
              switch (op[2] & 0x00)
15727
178
              {
15728
178
                case 0x00:
15729
178
                  goto op_semantics_137;
15730
0
                  break;
15731
178
              }
15732
0
            break;
15733
77
          case 0xa4:
15734
77
              GETBYTE ();
15735
77
              switch (op[2] & 0x00)
15736
77
              {
15737
72
                case 0x00:
15738
72
                  goto op_semantics_137;
15739
0
                  break;
15740
77
              }
15741
0
            break;
15742
52
          case 0xa5:
15743
52
              GETBYTE ();
15744
52
              switch (op[2] & 0x00)
15745
52
              {
15746
52
                case 0x00:
15747
52
                  goto op_semantics_137;
15748
0
                  break;
15749
52
              }
15750
0
            break;
15751
79
          case 0xa6:
15752
79
              GETBYTE ();
15753
79
              switch (op[2] & 0x00)
15754
79
              {
15755
79
                case 0x00:
15756
79
                  goto op_semantics_137;
15757
0
                  break;
15758
79
              }
15759
0
            break;
15760
44
          case 0xa7:
15761
44
              GETBYTE ();
15762
44
              switch (op[2] & 0x00)
15763
44
              {
15764
44
                case 0x00:
15765
44
                  goto op_semantics_137;
15766
0
                  break;
15767
44
              }
15768
0
            break;
15769
54
          case 0xa8:
15770
54
              GETBYTE ();
15771
54
              switch (op[2] & 0x00)
15772
54
              {
15773
54
                case 0x00:
15774
54
                  goto op_semantics_137;
15775
0
                  break;
15776
54
              }
15777
0
            break;
15778
46
          case 0xa9:
15779
46
              GETBYTE ();
15780
46
              switch (op[2] & 0x00)
15781
46
              {
15782
46
                case 0x00:
15783
46
                  goto op_semantics_137;
15784
0
                  break;
15785
46
              }
15786
0
            break;
15787
101
          case 0xaa:
15788
101
              GETBYTE ();
15789
101
              switch (op[2] & 0x00)
15790
101
              {
15791
101
                case 0x00:
15792
101
                  goto op_semantics_137;
15793
0
                  break;
15794
101
              }
15795
0
            break;
15796
130
          case 0xab:
15797
130
              GETBYTE ();
15798
130
              switch (op[2] & 0x00)
15799
130
              {
15800
130
                case 0x00:
15801
130
                  goto op_semantics_137;
15802
0
                  break;
15803
130
              }
15804
0
            break;
15805
168
          case 0xac:
15806
168
              GETBYTE ();
15807
168
              switch (op[2] & 0x00)
15808
168
              {
15809
168
                case 0x00:
15810
168
                  goto op_semantics_137;
15811
0
                  break;
15812
168
              }
15813
0
            break;
15814
17
          case 0xad:
15815
17
              GETBYTE ();
15816
17
              switch (op[2] & 0x00)
15817
17
              {
15818
17
                case 0x00:
15819
17
                  goto op_semantics_137;
15820
0
                  break;
15821
17
              }
15822
0
            break;
15823
286
          case 0xae:
15824
286
              GETBYTE ();
15825
286
              switch (op[2] & 0x00)
15826
286
              {
15827
286
                case 0x00:
15828
286
                  goto op_semantics_137;
15829
0
                  break;
15830
286
              }
15831
0
            break;
15832
58
          case 0xaf:
15833
58
              GETBYTE ();
15834
58
              switch (op[2] & 0x00)
15835
58
              {
15836
58
                case 0x00:
15837
58
                  goto op_semantics_137;
15838
0
                  break;
15839
58
              }
15840
0
            break;
15841
79
          case 0xb0:
15842
79
              GETBYTE ();
15843
79
              switch (op[2] & 0x00)
15844
79
              {
15845
79
                case 0x00:
15846
79
                  goto op_semantics_137;
15847
0
                  break;
15848
79
              }
15849
0
            break;
15850
46
          case 0xb1:
15851
46
              GETBYTE ();
15852
46
              switch (op[2] & 0x00)
15853
46
              {
15854
46
                case 0x00:
15855
46
                  goto op_semantics_137;
15856
0
                  break;
15857
46
              }
15858
0
            break;
15859
171
          case 0xb2:
15860
171
              GETBYTE ();
15861
171
              switch (op[2] & 0x00)
15862
171
              {
15863
171
                case 0x00:
15864
171
                  goto op_semantics_137;
15865
0
                  break;
15866
171
              }
15867
0
            break;
15868
75
          case 0xb3:
15869
75
              GETBYTE ();
15870
75
              switch (op[2] & 0x00)
15871
75
              {
15872
75
                case 0x00:
15873
75
                  goto op_semantics_137;
15874
0
                  break;
15875
75
              }
15876
0
            break;
15877
118
          case 0xb4:
15878
118
              GETBYTE ();
15879
118
              switch (op[2] & 0x00)
15880
118
              {
15881
118
                case 0x00:
15882
118
                  goto op_semantics_137;
15883
0
                  break;
15884
118
              }
15885
0
            break;
15886
60
          case 0xb5:
15887
60
              GETBYTE ();
15888
60
              switch (op[2] & 0x00)
15889
60
              {
15890
60
                case 0x00:
15891
60
                  goto op_semantics_137;
15892
0
                  break;
15893
60
              }
15894
0
            break;
15895
30
          case 0xb6:
15896
30
              GETBYTE ();
15897
30
              switch (op[2] & 0x00)
15898
30
              {
15899
30
                case 0x00:
15900
30
                  goto op_semantics_137;
15901
0
                  break;
15902
30
              }
15903
0
            break;
15904
139
          case 0xb7:
15905
139
              GETBYTE ();
15906
139
              switch (op[2] & 0x00)
15907
139
              {
15908
139
                case 0x00:
15909
139
                  goto op_semantics_137;
15910
0
                  break;
15911
139
              }
15912
0
            break;
15913
378
          case 0xb8:
15914
378
              GETBYTE ();
15915
378
              switch (op[2] & 0x00)
15916
378
              {
15917
378
                case 0x00:
15918
378
                  goto op_semantics_137;
15919
0
                  break;
15920
378
              }
15921
0
            break;
15922
719
          case 0xb9:
15923
719
              GETBYTE ();
15924
719
              switch (op[2] & 0x00)
15925
719
              {
15926
718
                case 0x00:
15927
718
                  goto op_semantics_137;
15928
0
                  break;
15929
719
              }
15930
0
            break;
15931
42
          case 0xba:
15932
42
              GETBYTE ();
15933
42
              switch (op[2] & 0x00)
15934
42
              {
15935
42
                case 0x00:
15936
42
                  goto op_semantics_137;
15937
0
                  break;
15938
42
              }
15939
0
            break;
15940
155
          case 0xbb:
15941
155
              GETBYTE ();
15942
155
              switch (op[2] & 0x00)
15943
155
              {
15944
155
                case 0x00:
15945
155
                  goto op_semantics_137;
15946
0
                  break;
15947
155
              }
15948
0
            break;
15949
58
          case 0xbc:
15950
58
              GETBYTE ();
15951
58
              switch (op[2] & 0x00)
15952
58
              {
15953
58
                case 0x00:
15954
58
                  goto op_semantics_137;
15955
0
                  break;
15956
58
              }
15957
0
            break;
15958
161
          case 0xbd:
15959
161
              GETBYTE ();
15960
161
              switch (op[2] & 0x00)
15961
161
              {
15962
161
                case 0x00:
15963
161
                  goto op_semantics_137;
15964
0
                  break;
15965
161
              }
15966
0
            break;
15967
188
          case 0xbe:
15968
188
              GETBYTE ();
15969
188
              switch (op[2] & 0x00)
15970
188
              {
15971
188
                case 0x00:
15972
188
                  goto op_semantics_137;
15973
0
                  break;
15974
188
              }
15975
0
            break;
15976
135
          case 0xbf:
15977
135
              GETBYTE ();
15978
135
              switch (op[2] & 0x00)
15979
135
              {
15980
135
                case 0x00:
15981
135
                  goto op_semantics_137;
15982
0
                  break;
15983
135
              }
15984
0
            break;
15985
147
          case 0xc0:
15986
147
              GETBYTE ();
15987
147
              switch (op[2] & 0x00)
15988
147
              {
15989
147
                case 0x00:
15990
4.65k
                  op_semantics_138:
15991
4.65k
                    {
15992
                      /** 1111 1101 110immmm rsrc rdst  shll  #%2, %1, %0 */
15993
4.65k
#line 737 "rx-decode.opc"
15994
4.65k
                      int immmm AU = op[1] & 0x1f;
15995
4.65k
#line 737 "rx-decode.opc"
15996
4.65k
                      int rsrc AU = (op[2] >> 4) & 0x0f;
15997
4.65k
#line 737 "rx-decode.opc"
15998
4.65k
                      int rdst AU = op[2] & 0x0f;
15999
4.65k
                      if (trace)
16000
0
                        {
16001
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16002
0
                                 "/** 1111 1101 110immmm rsrc rdst  shll  #%2, %1, %0 */",
16003
0
                                 op[0], op[1], op[2]);
16004
0
                          printf ("  immmm = 0x%x,", immmm);
16005
0
                          printf ("  rsrc = 0x%x,", rsrc);
16006
0
                          printf ("  rdst = 0x%x\n", rdst);
16007
0
                        }
16008
4.65k
                      SYNTAX("shll  #%2, %1, %0");
16009
4.65k
#line 737 "rx-decode.opc"
16010
4.65k
                      ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
16011
16012
16013
4.65k
                    }
16014
4.65k
                  break;
16015
147
              }
16016
4.65k
            break;
16017
4.65k
          case 0xc1:
16018
191
              GETBYTE ();
16019
191
              switch (op[2] & 0x00)
16020
191
              {
16021
191
                case 0x00:
16022
191
                  goto op_semantics_138;
16023
0
                  break;
16024
191
              }
16025
0
            break;
16026
169
          case 0xc2:
16027
169
              GETBYTE ();
16028
169
              switch (op[2] & 0x00)
16029
169
              {
16030
169
                case 0x00:
16031
169
                  goto op_semantics_138;
16032
0
                  break;
16033
169
              }
16034
0
            break;
16035
357
          case 0xc3:
16036
357
              GETBYTE ();
16037
357
              switch (op[2] & 0x00)
16038
357
              {
16039
357
                case 0x00:
16040
357
                  goto op_semantics_138;
16041
0
                  break;
16042
357
              }
16043
0
            break;
16044
72
          case 0xc4:
16045
72
              GETBYTE ();
16046
72
              switch (op[2] & 0x00)
16047
72
              {
16048
72
                case 0x00:
16049
72
                  goto op_semantics_138;
16050
0
                  break;
16051
72
              }
16052
0
            break;
16053
184
          case 0xc5:
16054
184
              GETBYTE ();
16055
184
              switch (op[2] & 0x00)
16056
184
              {
16057
183
                case 0x00:
16058
183
                  goto op_semantics_138;
16059
0
                  break;
16060
184
              }
16061
0
            break;
16062
81
          case 0xc6:
16063
81
              GETBYTE ();
16064
81
              switch (op[2] & 0x00)
16065
81
              {
16066
81
                case 0x00:
16067
81
                  goto op_semantics_138;
16068
0
                  break;
16069
81
              }
16070
0
            break;
16071
26
          case 0xc7:
16072
26
              GETBYTE ();
16073
26
              switch (op[2] & 0x00)
16074
26
              {
16075
26
                case 0x00:
16076
26
                  goto op_semantics_138;
16077
0
                  break;
16078
26
              }
16079
0
            break;
16080
40
          case 0xc8:
16081
40
              GETBYTE ();
16082
40
              switch (op[2] & 0x00)
16083
40
              {
16084
39
                case 0x00:
16085
39
                  goto op_semantics_138;
16086
0
                  break;
16087
40
              }
16088
0
            break;
16089
78
          case 0xc9:
16090
78
              GETBYTE ();
16091
78
              switch (op[2] & 0x00)
16092
78
              {
16093
78
                case 0x00:
16094
78
                  goto op_semantics_138;
16095
0
                  break;
16096
78
              }
16097
0
            break;
16098
132
          case 0xca:
16099
132
              GETBYTE ();
16100
132
              switch (op[2] & 0x00)
16101
132
              {
16102
132
                case 0x00:
16103
132
                  goto op_semantics_138;
16104
0
                  break;
16105
132
              }
16106
0
            break;
16107
297
          case 0xcb:
16108
297
              GETBYTE ();
16109
297
              switch (op[2] & 0x00)
16110
297
              {
16111
297
                case 0x00:
16112
297
                  goto op_semantics_138;
16113
0
                  break;
16114
297
              }
16115
0
            break;
16116
144
          case 0xcc:
16117
144
              GETBYTE ();
16118
144
              switch (op[2] & 0x00)
16119
144
              {
16120
133
                case 0x00:
16121
133
                  goto op_semantics_138;
16122
0
                  break;
16123
144
              }
16124
0
            break;
16125
389
          case 0xcd:
16126
389
              GETBYTE ();
16127
389
              switch (op[2] & 0x00)
16128
389
              {
16129
389
                case 0x00:
16130
389
                  goto op_semantics_138;
16131
0
                  break;
16132
389
              }
16133
0
            break;
16134
240
          case 0xce:
16135
240
              GETBYTE ();
16136
240
              switch (op[2] & 0x00)
16137
240
              {
16138
240
                case 0x00:
16139
240
                  goto op_semantics_138;
16140
0
                  break;
16141
240
              }
16142
0
            break;
16143
66
          case 0xcf:
16144
66
              GETBYTE ();
16145
66
              switch (op[2] & 0x00)
16146
66
              {
16147
66
                case 0x00:
16148
66
                  goto op_semantics_138;
16149
0
                  break;
16150
66
              }
16151
0
            break;
16152
143
          case 0xd0:
16153
143
              GETBYTE ();
16154
143
              switch (op[2] & 0x00)
16155
143
              {
16156
143
                case 0x00:
16157
143
                  goto op_semantics_138;
16158
0
                  break;
16159
143
              }
16160
0
            break;
16161
79
          case 0xd1:
16162
79
              GETBYTE ();
16163
79
              switch (op[2] & 0x00)
16164
79
              {
16165
79
                case 0x00:
16166
79
                  goto op_semantics_138;
16167
0
                  break;
16168
79
              }
16169
0
            break;
16170
3
          case 0xd2:
16171
3
              GETBYTE ();
16172
3
              switch (op[2] & 0x00)
16173
3
              {
16174
3
                case 0x00:
16175
3
                  goto op_semantics_138;
16176
0
                  break;
16177
3
              }
16178
0
            break;
16179
382
          case 0xd3:
16180
382
              GETBYTE ();
16181
382
              switch (op[2] & 0x00)
16182
382
              {
16183
382
                case 0x00:
16184
382
                  goto op_semantics_138;
16185
0
                  break;
16186
382
              }
16187
0
            break;
16188
183
          case 0xd4:
16189
183
              GETBYTE ();
16190
183
              switch (op[2] & 0x00)
16191
183
              {
16192
183
                case 0x00:
16193
183
                  goto op_semantics_138;
16194
0
                  break;
16195
183
              }
16196
0
            break;
16197
73
          case 0xd5:
16198
73
              GETBYTE ();
16199
73
              switch (op[2] & 0x00)
16200
73
              {
16201
73
                case 0x00:
16202
73
                  goto op_semantics_138;
16203
0
                  break;
16204
73
              }
16205
0
            break;
16206
365
          case 0xd6:
16207
365
              GETBYTE ();
16208
365
              switch (op[2] & 0x00)
16209
365
              {
16210
365
                case 0x00:
16211
365
                  goto op_semantics_138;
16212
0
                  break;
16213
365
              }
16214
0
            break;
16215
149
          case 0xd7:
16216
149
              GETBYTE ();
16217
149
              switch (op[2] & 0x00)
16218
149
              {
16219
149
                case 0x00:
16220
149
                  goto op_semantics_138;
16221
0
                  break;
16222
149
              }
16223
0
            break;
16224
88
          case 0xd8:
16225
88
              GETBYTE ();
16226
88
              switch (op[2] & 0x00)
16227
88
              {
16228
88
                case 0x00:
16229
88
                  goto op_semantics_138;
16230
0
                  break;
16231
88
              }
16232
0
            break;
16233
18
          case 0xd9:
16234
18
              GETBYTE ();
16235
18
              switch (op[2] & 0x00)
16236
18
              {
16237
18
                case 0x00:
16238
18
                  goto op_semantics_138;
16239
0
                  break;
16240
18
              }
16241
0
            break;
16242
61
          case 0xda:
16243
61
              GETBYTE ();
16244
61
              switch (op[2] & 0x00)
16245
61
              {
16246
61
                case 0x00:
16247
61
                  goto op_semantics_138;
16248
0
                  break;
16249
61
              }
16250
0
            break;
16251
23
          case 0xdb:
16252
23
              GETBYTE ();
16253
23
              switch (op[2] & 0x00)
16254
23
              {
16255
23
                case 0x00:
16256
23
                  goto op_semantics_138;
16257
0
                  break;
16258
23
              }
16259
0
            break;
16260
78
          case 0xdc:
16261
78
              GETBYTE ();
16262
78
              switch (op[2] & 0x00)
16263
78
              {
16264
78
                case 0x00:
16265
78
                  goto op_semantics_138;
16266
0
                  break;
16267
78
              }
16268
0
            break;
16269
109
          case 0xdd:
16270
109
              GETBYTE ();
16271
109
              switch (op[2] & 0x00)
16272
109
              {
16273
109
                case 0x00:
16274
109
                  goto op_semantics_138;
16275
0
                  break;
16276
109
              }
16277
0
            break;
16278
89
          case 0xde:
16279
89
              GETBYTE ();
16280
89
              switch (op[2] & 0x00)
16281
89
              {
16282
88
                case 0x00:
16283
88
                  goto op_semantics_138;
16284
0
                  break;
16285
89
              }
16286
0
            break;
16287
210
          case 0xdf:
16288
210
              GETBYTE ();
16289
210
              switch (op[2] & 0x00)
16290
210
              {
16291
210
                case 0x00:
16292
210
                  goto op_semantics_138;
16293
0
                  break;
16294
210
              }
16295
0
            break;
16296
127
          case 0xe0:
16297
127
              GETBYTE ();
16298
127
              switch (op[2] & 0xf0)
16299
127
              {
16300
0
                case 0x00:
16301
52
                case 0x10:
16302
52
                case 0x20:
16303
65
                case 0x30:
16304
65
                case 0x40:
16305
65
                case 0x50:
16306
65
                case 0x60:
16307
67
                case 0x70:
16308
67
                case 0x80:
16309
67
                case 0x90:
16310
67
                case 0xa0:
16311
67
                case 0xb0:
16312
67
                case 0xc0:
16313
67
                case 0xd0:
16314
95
                case 0xe0:
16315
12.6k
                  op_semantics_139:
16316
12.6k
                    {
16317
                      /** 1111 1101 111 bittt cond rdst bm%2  #%1, %0%S0 */
16318
12.6k
#line 1011 "rx-decode.opc"
16319
12.6k
                      int bittt AU = op[1] & 0x1f;
16320
12.6k
#line 1011 "rx-decode.opc"
16321
12.6k
                      int cond AU = (op[2] >> 4) & 0x0f;
16322
12.6k
#line 1011 "rx-decode.opc"
16323
12.6k
                      int rdst AU = op[2] & 0x0f;
16324
12.6k
                      if (trace)
16325
0
                        {
16326
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16327
0
                                 "/** 1111 1101 111 bittt cond rdst bm%2  #%1, %0%S0 */",
16328
0
                                 op[0], op[1], op[2]);
16329
0
                          printf ("  bittt = 0x%x,", bittt);
16330
0
                          printf ("  cond = 0x%x,", cond);
16331
0
                          printf ("  rdst = 0x%x\n", rdst);
16332
0
                        }
16333
12.6k
                      SYNTAX("bm%2  #%1, %0%S0");
16334
12.6k
#line 1011 "rx-decode.opc"
16335
12.6k
                      ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16336
16337
                    /*----------------------------------------------------------------------*/
16338
                    /* CONTROL REGISTERS              */
16339
16340
12.6k
                    }
16341
12.6k
                  break;
16342
32
                case 0xf0:
16343
14.8k
                  op_semantics_140:
16344
14.8k
                    {
16345
                      /** 1111 1101 111bittt 1111 rdst  bnot  #%1, %0 */
16346
14.8k
#line 1004 "rx-decode.opc"
16347
14.8k
                      int bittt AU = op[1] & 0x1f;
16348
14.8k
#line 1004 "rx-decode.opc"
16349
14.8k
                      int rdst AU = op[2] & 0x0f;
16350
14.8k
                      if (trace)
16351
0
                        {
16352
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16353
0
                                 "/** 1111 1101 111bittt 1111 rdst  bnot  #%1, %0 */",
16354
0
                                 op[0], op[1], op[2]);
16355
0
                          printf ("  bittt = 0x%x,", bittt);
16356
0
                          printf ("  rdst = 0x%x\n", rdst);
16357
0
                        }
16358
14.8k
                      SYNTAX("bnot  #%1, %0");
16359
14.8k
#line 1004 "rx-decode.opc"
16360
14.8k
                      ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16361
16362
16363
14.8k
                    }
16364
14.8k
                  break;
16365
127
              }
16366
27.5k
            break;
16367
27.5k
          case 0xe1:
16368
235
              GETBYTE ();
16369
235
              switch (op[2] & 0xf0)
16370
235
              {
16371
2
                case 0x00:
16372
2
                case 0x10:
16373
2
                case 0x20:
16374
9
                case 0x30:
16375
9
                case 0x40:
16376
23
                case 0x50:
16377
23
                case 0x60:
16378
47
                case 0x70:
16379
121
                case 0x80:
16380
150
                case 0x90:
16381
150
                case 0xa0:
16382
160
                case 0xb0:
16383
160
                case 0xc0:
16384
160
                case 0xd0:
16385
173
                case 0xe0:
16386
173
                  goto op_semantics_139;
16387
0
                  break;
16388
62
                case 0xf0:
16389
62
                  goto op_semantics_140;
16390
0
                  break;
16391
235
              }
16392
0
            break;
16393
336
          case 0xe2:
16394
336
              GETBYTE ();
16395
336
              switch (op[2] & 0xf0)
16396
336
              {
16397
72
                case 0x00:
16398
72
                case 0x10:
16399
72
                case 0x20:
16400
92
                case 0x30:
16401
92
                case 0x40:
16402
92
                case 0x50:
16403
92
                case 0x60:
16404
92
                case 0x70:
16405
134
                case 0x80:
16406
267
                case 0x90:
16407
267
                case 0xa0:
16408
267
                case 0xb0:
16409
267
                case 0xc0:
16410
267
                case 0xd0:
16411
269
                case 0xe0:
16412
269
                  goto op_semantics_139;
16413
0
                  break;
16414
67
                case 0xf0:
16415
67
                  goto op_semantics_140;
16416
0
                  break;
16417
336
              }
16418
0
            break;
16419
238
          case 0xe3:
16420
238
              GETBYTE ();
16421
238
              switch (op[2] & 0xf0)
16422
238
              {
16423
94
                case 0x00:
16424
94
                case 0x10:
16425
94
                case 0x20:
16426
94
                case 0x30:
16427
94
                case 0x40:
16428
99
                case 0x50:
16429
99
                case 0x60:
16430
99
                case 0x70:
16431
99
                case 0x80:
16432
99
                case 0x90:
16433
99
                case 0xa0:
16434
99
                case 0xb0:
16435
99
                case 0xc0:
16436
100
                case 0xd0:
16437
101
                case 0xe0:
16438
101
                  goto op_semantics_139;
16439
0
                  break;
16440
103
                case 0xf0:
16441
103
                  goto op_semantics_140;
16442
0
                  break;
16443
238
              }
16444
0
            break;
16445
129
          case 0xe4:
16446
129
              GETBYTE ();
16447
129
              switch (op[2] & 0xf0)
16448
129
              {
16449
34
                case 0x00:
16450
36
                case 0x10:
16451
63
                case 0x20:
16452
63
                case 0x30:
16453
95
                case 0x40:
16454
102
                case 0x50:
16455
103
                case 0x60:
16456
116
                case 0x70:
16457
116
                case 0x80:
16458
116
                case 0x90:
16459
119
                case 0xa0:
16460
119
                case 0xb0:
16461
119
                case 0xc0:
16462
119
                case 0xd0:
16463
123
                case 0xe0:
16464
123
                  goto op_semantics_139;
16465
0
                  break;
16466
6
                case 0xf0:
16467
6
                  goto op_semantics_140;
16468
0
                  break;
16469
129
              }
16470
0
            break;
16471
915
          case 0xe5:
16472
915
              GETBYTE ();
16473
915
              switch (op[2] & 0xf0)
16474
915
              {
16475
320
                case 0x00:
16476
327
                case 0x10:
16477
328
                case 0x20:
16478
328
                case 0x30:
16479
405
                case 0x40:
16480
405
                case 0x50:
16481
418
                case 0x60:
16482
420
                case 0x70:
16483
420
                case 0x80:
16484
421
                case 0x90:
16485
421
                case 0xa0:
16486
421
                case 0xb0:
16487
421
                case 0xc0:
16488
421
                case 0xd0:
16489
424
                case 0xe0:
16490
424
                  goto op_semantics_139;
16491
0
                  break;
16492
491
                case 0xf0:
16493
491
                  goto op_semantics_140;
16494
0
                  break;
16495
915
              }
16496
0
            break;
16497
167
          case 0xe6:
16498
167
              GETBYTE ();
16499
167
              switch (op[2] & 0xf0)
16500
167
              {
16501
6
                case 0x00:
16502
7
                case 0x10:
16503
7
                case 0x20:
16504
7
                case 0x30:
16505
122
                case 0x40:
16506
126
                case 0x50:
16507
126
                case 0x60:
16508
130
                case 0x70:
16509
130
                case 0x80:
16510
130
                case 0x90:
16511
130
                case 0xa0:
16512
130
                case 0xb0:
16513
130
                case 0xc0:
16514
130
                case 0xd0:
16515
131
                case 0xe0:
16516
131
                  goto op_semantics_139;
16517
0
                  break;
16518
36
                case 0xf0:
16519
36
                  goto op_semantics_140;
16520
0
                  break;
16521
167
              }
16522
0
            break;
16523
83
          case 0xe7:
16524
83
              GETBYTE ();
16525
83
              switch (op[2] & 0xf0)
16526
83
              {
16527
0
                case 0x00:
16528
0
                case 0x10:
16529
0
                case 0x20:
16530
60
                case 0x30:
16531
60
                case 0x40:
16532
60
                case 0x50:
16533
63
                case 0x60:
16534
63
                case 0x70:
16535
64
                case 0x80:
16536
64
                case 0x90:
16537
64
                case 0xa0:
16538
64
                case 0xb0:
16539
64
                case 0xc0:
16540
64
                case 0xd0:
16541
76
                case 0xe0:
16542
76
                  goto op_semantics_139;
16543
0
                  break;
16544
7
                case 0xf0:
16545
7
                  goto op_semantics_140;
16546
0
                  break;
16547
83
              }
16548
0
            break;
16549
201
          case 0xe8:
16550
201
              GETBYTE ();
16551
201
              switch (op[2] & 0xf0)
16552
201
              {
16553
77
                case 0x00:
16554
150
                case 0x10:
16555
169
                case 0x20:
16556
169
                case 0x30:
16557
169
                case 0x40:
16558
169
                case 0x50:
16559
169
                case 0x60:
16560
169
                case 0x70:
16561
169
                case 0x80:
16562
170
                case 0x90:
16563
173
                case 0xa0:
16564
173
                case 0xb0:
16565
173
                case 0xc0:
16566
173
                case 0xd0:
16567
173
                case 0xe0:
16568
173
                  goto op_semantics_139;
16569
0
                  break;
16570
28
                case 0xf0:
16571
28
                  goto op_semantics_140;
16572
0
                  break;
16573
201
              }
16574
0
            break;
16575
114
          case 0xe9:
16576
114
              GETBYTE ();
16577
114
              switch (op[2] & 0xf0)
16578
114
              {
16579
0
                case 0x00:
16580
19
                case 0x10:
16581
19
                case 0x20:
16582
19
                case 0x30:
16583
20
                case 0x40:
16584
20
                case 0x50:
16585
22
                case 0x60:
16586
22
                case 0x70:
16587
22
                case 0x80:
16588
22
                case 0x90:
16589
22
                case 0xa0:
16590
68
                case 0xb0:
16591
68
                case 0xc0:
16592
68
                case 0xd0:
16593
101
                case 0xe0:
16594
101
                  goto op_semantics_139;
16595
0
                  break;
16596
13
                case 0xf0:
16597
13
                  goto op_semantics_140;
16598
0
                  break;
16599
114
              }
16600
0
            break;
16601
117
          case 0xea:
16602
117
              GETBYTE ();
16603
117
              switch (op[2] & 0xf0)
16604
117
              {
16605
32
                case 0x00:
16606
35
                case 0x10:
16607
37
                case 0x20:
16608
37
                case 0x30:
16609
39
                case 0x40:
16610
39
                case 0x50:
16611
39
                case 0x60:
16612
48
                case 0x70:
16613
48
                case 0x80:
16614
48
                case 0x90:
16615
48
                case 0xa0:
16616
48
                case 0xb0:
16617
56
                case 0xc0:
16618
56
                case 0xd0:
16619
69
                case 0xe0:
16620
69
                  goto op_semantics_139;
16621
0
                  break;
16622
48
                case 0xf0:
16623
48
                  goto op_semantics_140;
16624
0
                  break;
16625
117
              }
16626
0
            break;
16627
435
          case 0xeb:
16628
435
              GETBYTE ();
16629
435
              switch (op[2] & 0xf0)
16630
435
              {
16631
27
                case 0x00:
16632
40
                case 0x10:
16633
40
                case 0x20:
16634
41
                case 0x30:
16635
41
                case 0x40:
16636
41
                case 0x50:
16637
41
                case 0x60:
16638
42
                case 0x70:
16639
42
                case 0x80:
16640
422
                case 0x90:
16641
422
                case 0xa0:
16642
422
                case 0xb0:
16643
422
                case 0xc0:
16644
422
                case 0xd0:
16645
422
                case 0xe0:
16646
422
                  goto op_semantics_139;
16647
0
                  break;
16648
13
                case 0xf0:
16649
13
                  goto op_semantics_140;
16650
0
                  break;
16651
435
              }
16652
0
            break;
16653
388
          case 0xec:
16654
388
              GETBYTE ();
16655
388
              switch (op[2] & 0xf0)
16656
388
              {
16657
246
                case 0x00:
16658
246
                case 0x10:
16659
246
                case 0x20:
16660
307
                case 0x30:
16661
307
                case 0x40:
16662
307
                case 0x50:
16663
307
                case 0x60:
16664
326
                case 0x70:
16665
338
                case 0x80:
16666
338
                case 0x90:
16667
341
                case 0xa0:
16668
341
                case 0xb0:
16669
341
                case 0xc0:
16670
341
                case 0xd0:
16671
343
                case 0xe0:
16672
343
                  goto op_semantics_139;
16673
0
                  break;
16674
39
                case 0xf0:
16675
39
                  goto op_semantics_140;
16676
0
                  break;
16677
388
              }
16678
0
            break;
16679
925
          case 0xed:
16680
925
              GETBYTE ();
16681
925
              switch (op[2] & 0xf0)
16682
925
              {
16683
65
                case 0x00:
16684
66
                case 0x10:
16685
66
                case 0x20:
16686
71
                case 0x30:
16687
71
                case 0x40:
16688
84
                case 0x50:
16689
84
                case 0x60:
16690
84
                case 0x70:
16691
99
                case 0x80:
16692
194
                case 0x90:
16693
200
                case 0xa0:
16694
200
                case 0xb0:
16695
202
                case 0xc0:
16696
211
                case 0xd0:
16697
216
                case 0xe0:
16698
216
                  goto op_semantics_139;
16699
0
                  break;
16700
708
                case 0xf0:
16701
708
                  goto op_semantics_140;
16702
0
                  break;
16703
925
              }
16704
0
            break;
16705
726
          case 0xee:
16706
726
              GETBYTE ();
16707
726
              switch (op[2] & 0xf0)
16708
726
              {
16709
8
                case 0x00:
16710
8
                case 0x10:
16711
8
                case 0x20:
16712
8
                case 0x30:
16713
8
                case 0x40:
16714
65
                case 0x50:
16715
257
                case 0x60:
16716
257
                case 0x70:
16717
263
                case 0x80:
16718
263
                case 0x90:
16719
354
                case 0xa0:
16720
354
                case 0xb0:
16721
354
                case 0xc0:
16722
354
                case 0xd0:
16723
362
                case 0xe0:
16724
362
                  goto op_semantics_139;
16725
0
                  break;
16726
364
                case 0xf0:
16727
364
                  goto op_semantics_140;
16728
0
                  break;
16729
726
              }
16730
0
            break;
16731
1.88k
          case 0xef:
16732
1.88k
              GETBYTE ();
16733
1.88k
              switch (op[2] & 0xf0)
16734
1.88k
              {
16735
65
                case 0x00:
16736
1.57k
                case 0x10:
16737
1.57k
                case 0x20:
16738
1.57k
                case 0x30:
16739
1.57k
                case 0x40:
16740
1.57k
                case 0x50:
16741
1.61k
                case 0x60:
16742
1.61k
                case 0x70:
16743
1.82k
                case 0x80:
16744
1.82k
                case 0x90:
16745
1.83k
                case 0xa0:
16746
1.83k
                case 0xb0:
16747
1.83k
                case 0xc0:
16748
1.83k
                case 0xd0:
16749
1.83k
                case 0xe0:
16750
1.83k
                  goto op_semantics_139;
16751
0
                  break;
16752
46
                case 0xf0:
16753
46
                  goto op_semantics_140;
16754
0
                  break;
16755
1.88k
              }
16756
0
            break;
16757
97
          case 0xf0:
16758
97
              GETBYTE ();
16759
97
              switch (op[2] & 0xf0)
16760
97
              {
16761
23
                case 0x00:
16762
23
                case 0x10:
16763
23
                case 0x20:
16764
23
                case 0x30:
16765
25
                case 0x40:
16766
25
                case 0x50:
16767
25
                case 0x60:
16768
25
                case 0x70:
16769
25
                case 0x80:
16770
77
                case 0x90:
16771
77
                case 0xa0:
16772
82
                case 0xb0:
16773
82
                case 0xc0:
16774
82
                case 0xd0:
16775
86
                case 0xe0:
16776
86
                  goto op_semantics_139;
16777
0
                  break;
16778
11
                case 0xf0:
16779
11
                  goto op_semantics_140;
16780
0
                  break;
16781
97
              }
16782
0
            break;
16783
122
          case 0xf1:
16784
122
              GETBYTE ();
16785
122
              switch (op[2] & 0xf0)
16786
122
              {
16787
12
                case 0x00:
16788
16
                case 0x10:
16789
17
                case 0x20:
16790
17
                case 0x30:
16791
17
                case 0x40:
16792
17
                case 0x50:
16793
17
                case 0x60:
16794
17
                case 0x70:
16795
17
                case 0x80:
16796
17
                case 0x90:
16797
17
                case 0xa0:
16798
17
                case 0xb0:
16799
34
                case 0xc0:
16800
41
                case 0xd0:
16801
41
                case 0xe0:
16802
41
                  goto op_semantics_139;
16803
0
                  break;
16804
81
                case 0xf0:
16805
81
                  goto op_semantics_140;
16806
0
                  break;
16807
122
              }
16808
0
            break;
16809
145
          case 0xf2:
16810
145
              GETBYTE ();
16811
145
              switch (op[2] & 0xf0)
16812
145
              {
16813
0
                case 0x00:
16814
1
                case 0x10:
16815
1
                case 0x20:
16816
78
                case 0x30:
16817
78
                case 0x40:
16818
79
                case 0x50:
16819
79
                case 0x60:
16820
79
                case 0x70:
16821
81
                case 0x80:
16822
81
                case 0x90:
16823
81
                case 0xa0:
16824
95
                case 0xb0:
16825
95
                case 0xc0:
16826
95
                case 0xd0:
16827
95
                case 0xe0:
16828
95
                  goto op_semantics_139;
16829
0
                  break;
16830
50
                case 0xf0:
16831
50
                  goto op_semantics_140;
16832
0
                  break;
16833
145
              }
16834
0
            break;
16835
198
          case 0xf3:
16836
198
              GETBYTE ();
16837
198
              switch (op[2] & 0xf0)
16838
198
              {
16839
3
                case 0x00:
16840
7
                case 0x10:
16841
8
                case 0x20:
16842
8
                case 0x30:
16843
8
                case 0x40:
16844
8
                case 0x50:
16845
20
                case 0x60:
16846
21
                case 0x70:
16847
21
                case 0x80:
16848
24
                case 0x90:
16849
27
                case 0xa0:
16850
27
                case 0xb0:
16851
27
                case 0xc0:
16852
27
                case 0xd0:
16853
34
                case 0xe0:
16854
34
                  goto op_semantics_139;
16855
0
                  break;
16856
164
                case 0xf0:
16857
164
                  goto op_semantics_140;
16858
0
                  break;
16859
198
              }
16860
0
            break;
16861
168
          case 0xf4:
16862
168
              GETBYTE ();
16863
168
              switch (op[2] & 0xf0)
16864
168
              {
16865
4
                case 0x00:
16866
4
                case 0x10:
16867
5
                case 0x20:
16868
5
                case 0x30:
16869
5
                case 0x40:
16870
5
                case 0x50:
16871
20
                case 0x60:
16872
20
                case 0x70:
16873
22
                case 0x80:
16874
22
                case 0x90:
16875
91
                case 0xa0:
16876
91
                case 0xb0:
16877
91
                case 0xc0:
16878
100
                case 0xd0:
16879
100
                case 0xe0:
16880
100
                  goto op_semantics_139;
16881
0
                  break;
16882
68
                case 0xf0:
16883
68
                  goto op_semantics_140;
16884
0
                  break;
16885
168
              }
16886
0
            break;
16887
144
          case 0xf5:
16888
144
              GETBYTE ();
16889
144
              switch (op[2] & 0xf0)
16890
144
              {
16891
0
                case 0x00:
16892
0
                case 0x10:
16893
79
                case 0x20:
16894
81
                case 0x30:
16895
81
                case 0x40:
16896
81
                case 0x50:
16897
88
                case 0x60:
16898
107
                case 0x70:
16899
107
                case 0x80:
16900
107
                case 0x90:
16901
107
                case 0xa0:
16902
107
                case 0xb0:
16903
107
                case 0xc0:
16904
111
                case 0xd0:
16905
111
                case 0xe0:
16906
111
                  goto op_semantics_139;
16907
0
                  break;
16908
33
                case 0xf0:
16909
33
                  goto op_semantics_140;
16910
0
                  break;
16911
144
              }
16912
0
            break;
16913
410
          case 0xf6:
16914
410
              GETBYTE ();
16915
410
              switch (op[2] & 0xf0)
16916
410
              {
16917
0
                case 0x00:
16918
0
                case 0x10:
16919
0
                case 0x20:
16920
6
                case 0x30:
16921
6
                case 0x40:
16922
6
                case 0x50:
16923
171
                case 0x60:
16924
171
                case 0x70:
16925
174
                case 0x80:
16926
177
                case 0x90:
16927
177
                case 0xa0:
16928
177
                case 0xb0:
16929
177
                case 0xc0:
16930
326
                case 0xd0:
16931
326
                case 0xe0:
16932
326
                  goto op_semantics_139;
16933
0
                  break;
16934
84
                case 0xf0:
16935
84
                  goto op_semantics_140;
16936
0
                  break;
16937
410
              }
16938
0
            break;
16939
139
          case 0xf7:
16940
139
              GETBYTE ();
16941
139
              switch (op[2] & 0xf0)
16942
139
              {
16943
1
                case 0x00:
16944
36
                case 0x10:
16945
36
                case 0x20:
16946
37
                case 0x30:
16947
55
                case 0x40:
16948
55
                case 0x50:
16949
70
                case 0x60:
16950
70
                case 0x70:
16951
71
                case 0x80:
16952
71
                case 0x90:
16953
71
                case 0xa0:
16954
75
                case 0xb0:
16955
75
                case 0xc0:
16956
75
                case 0xd0:
16957
75
                case 0xe0:
16958
75
                  goto op_semantics_139;
16959
0
                  break;
16960
64
                case 0xf0:
16961
64
                  goto op_semantics_140;
16962
0
                  break;
16963
139
              }
16964
0
            break;
16965
171
          case 0xf8:
16966
171
              GETBYTE ();
16967
171
              switch (op[2] & 0xf0)
16968
171
              {
16969
4
                case 0x00:
16970
4
                case 0x10:
16971
29
                case 0x20:
16972
66
                case 0x30:
16973
71
                case 0x40:
16974
71
                case 0x50:
16975
71
                case 0x60:
16976
78
                case 0x70:
16977
80
                case 0x80:
16978
94
                case 0x90:
16979
98
                case 0xa0:
16980
98
                case 0xb0:
16981
121
                case 0xc0:
16982
126
                case 0xd0:
16983
126
                case 0xe0:
16984
126
                  goto op_semantics_139;
16985
0
                  break;
16986
45
                case 0xf0:
16987
45
                  goto op_semantics_140;
16988
0
                  break;
16989
171
              }
16990
0
            break;
16991
1.14k
          case 0xf9:
16992
1.14k
              GETBYTE ();
16993
1.14k
              switch (op[2] & 0xf0)
16994
1.14k
              {
16995
119
                case 0x00:
16996
125
                case 0x10:
16997
1.01k
                case 0x20:
16998
1.01k
                case 0x30:
16999
1.01k
                case 0x40:
17000
1.01k
                case 0x50:
17001
1.01k
                case 0x60:
17002
1.01k
                case 0x70:
17003
1.01k
                case 0x80:
17004
1.01k
                case 0x90:
17005
1.02k
                case 0xa0:
17006
1.02k
                case 0xb0:
17007
1.08k
                case 0xc0:
17008
1.08k
                case 0xd0:
17009
1.08k
                case 0xe0:
17010
1.08k
                  goto op_semantics_139;
17011
0
                  break;
17012
57
                case 0xf0:
17013
57
                  goto op_semantics_140;
17014
0
                  break;
17015
1.14k
              }
17016
0
            break;
17017
221
          case 0xfa:
17018
221
              GETBYTE ();
17019
221
              switch (op[2] & 0xf0)
17020
221
              {
17021
5
                case 0x00:
17022
8
                case 0x10:
17023
17
                case 0x20:
17024
17
                case 0x30:
17025
17
                case 0x40:
17026
17
                case 0x50:
17027
19
                case 0x60:
17028
22
                case 0x70:
17029
64
                case 0x80:
17030
69
                case 0x90:
17031
69
                case 0xa0:
17032
74
                case 0xb0:
17033
109
                case 0xc0:
17034
109
                case 0xd0:
17035
109
                case 0xe0:
17036
109
                  goto op_semantics_139;
17037
0
                  break;
17038
112
                case 0xf0:
17039
112
                  goto op_semantics_140;
17040
0
                  break;
17041
221
              }
17042
0
            break;
17043
169
          case 0xfb:
17044
169
              GETBYTE ();
17045
169
              switch (op[2] & 0xf0)
17046
169
              {
17047
83
                case 0x00:
17048
83
                case 0x10:
17049
83
                case 0x20:
17050
83
                case 0x30:
17051
84
                case 0x40:
17052
84
                case 0x50:
17053
84
                case 0x60:
17054
84
                case 0x70:
17055
84
                case 0x80:
17056
84
                case 0x90:
17057
84
                case 0xa0:
17058
117
                case 0xb0:
17059
117
                case 0xc0:
17060
117
                case 0xd0:
17061
117
                case 0xe0:
17062
117
                  goto op_semantics_139;
17063
0
                  break;
17064
52
                case 0xf0:
17065
52
                  goto op_semantics_140;
17066
0
                  break;
17067
169
              }
17068
0
            break;
17069
1.31k
          case 0xfc:
17070
1.31k
              GETBYTE ();
17071
1.31k
              switch (op[2] & 0xf0)
17072
1.31k
              {
17073
119
                case 0x00:
17074
120
                case 0x10:
17075
120
                case 0x20:
17076
122
                case 0x30:
17077
122
                case 0x40:
17078
127
                case 0x50:
17079
222
                case 0x60:
17080
283
                case 0x70:
17081
286
                case 0x80:
17082
398
                case 0x90:
17083
407
                case 0xa0:
17084
407
                case 0xb0:
17085
408
                case 0xc0:
17086
408
                case 0xd0:
17087
431
                case 0xe0:
17088
431
                  goto op_semantics_139;
17089
0
                  break;
17090
888
                case 0xf0:
17091
888
                  goto op_semantics_140;
17092
0
                  break;
17093
1.31k
              }
17094
0
            break;
17095
10.6k
          case 0xfd:
17096
10.6k
              GETBYTE ();
17097
10.6k
              switch (op[2] & 0xf0)
17098
10.6k
              {
17099
470
                case 0x00:
17100
531
                case 0x10:
17101
1.52k
                case 0x20:
17102
1.83k
                case 0x30:
17103
1.86k
                case 0x40:
17104
1.87k
                case 0x50:
17105
1.95k
                case 0x60:
17106
2.29k
                case 0x70:
17107
2.30k
                case 0x80:
17108
2.31k
                case 0x90:
17109
2.32k
                case 0xa0:
17110
2.33k
                case 0xb0:
17111
2.62k
                case 0xc0:
17112
2.63k
                case 0xd0:
17113
2.73k
                case 0xe0:
17114
2.73k
                  goto op_semantics_139;
17115
0
                  break;
17116
7.91k
                case 0xf0:
17117
7.91k
                  goto op_semantics_140;
17118
0
                  break;
17119
10.6k
              }
17120
0
            break;
17121
744
          case 0xfe:
17122
744
              GETBYTE ();
17123
744
              switch (op[2] & 0xf0)
17124
744
              {
17125
71
                case 0x00:
17126
73
                case 0x10:
17127
84
                case 0x20:
17128
84
                case 0x30:
17129
86
                case 0x40:
17130
86
                case 0x50:
17131
91
                case 0x60:
17132
123
                case 0x70:
17133
123
                case 0x80:
17134
123
                case 0x90:
17135
123
                case 0xa0:
17136
127
                case 0xb0:
17137
130
                case 0xc0:
17138
130
                case 0xd0:
17139
304
                case 0xe0:
17140
304
                  goto op_semantics_139;
17141
0
                  break;
17142
440
                case 0xf0:
17143
440
                  goto op_semantics_140;
17144
0
                  break;
17145
744
              }
17146
0
            break;
17147
4.69k
          case 0xff:
17148
4.69k
              GETBYTE ();
17149
4.69k
              switch (op[2] & 0xf0)
17150
4.69k
              {
17151
1.26k
                case 0x00:
17152
1.37k
                case 0x10:
17153
1.50k
                case 0x20:
17154
1.56k
                case 0x30:
17155
1.59k
                case 0x40:
17156
1.64k
                case 0x50:
17157
1.64k
                case 0x60:
17158
1.65k
                case 0x70:
17159
1.81k
                case 0x80:
17160
1.82k
                case 0x90:
17161
1.83k
                case 0xa0:
17162
1.83k
                case 0xb0:
17163
1.83k
                case 0xc0:
17164
1.84k
                case 0xd0:
17165
1.93k
                case 0xe0:
17166
1.93k
                  goto op_semantics_139;
17167
0
                  break;
17168
2.76k
                case 0xf0:
17169
2.76k
                  goto op_semantics_140;
17170
0
                  break;
17171
4.69k
              }
17172
0
            break;
17173
5.73k
          default: UNSUPPORTED(); break;
17174
97.6k
        }
17175
97.5k
      break;
17176
97.5k
    case 0xfe:
17177
56.5k
        GETBYTE ();
17178
56.5k
        switch (op[1] & 0xff)
17179
56.5k
        {
17180
4.56k
          case 0x00:
17181
4.56k
              GETBYTE ();
17182
4.56k
              switch (op[2] & 0x00)
17183
4.56k
              {
17184
4.56k
                case 0x00:
17185
18.3k
                  op_semantics_141:
17186
18.3k
                    {
17187
                      /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
17188
18.3k
#line 363 "rx-decode.opc"
17189
18.3k
                      int sz AU = (op[1] >> 4) & 0x03;
17190
18.3k
#line 363 "rx-decode.opc"
17191
18.3k
                      int isrc AU = op[1] & 0x0f;
17192
18.3k
#line 363 "rx-decode.opc"
17193
18.3k
                      int bsrc AU = (op[2] >> 4) & 0x0f;
17194
18.3k
#line 363 "rx-decode.opc"
17195
18.3k
                      int rdst AU = op[2] & 0x0f;
17196
18.3k
                      if (trace)
17197
0
                        {
17198
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17199
0
                                 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
17200
0
                                 op[0], op[1], op[2]);
17201
0
                          printf ("  sz = 0x%x,", sz);
17202
0
                          printf ("  isrc = 0x%x,", isrc);
17203
0
                          printf ("  bsrc = 0x%x,", bsrc);
17204
0
                          printf ("  rdst = 0x%x\n", rdst);
17205
0
                        }
17206
18.3k
                      SYNTAX("mov%s %0, [%1, %2]");
17207
18.3k
#line 363 "rx-decode.opc"
17208
18.3k
                      ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17209
17210
18.3k
                    }
17211
18.3k
                  break;
17212
4.56k
              }
17213
18.3k
            break;
17214
18.3k
          case 0x01:
17215
646
              GETBYTE ();
17216
646
              switch (op[2] & 0x00)
17217
646
              {
17218
642
                case 0x00:
17219
642
                  goto op_semantics_141;
17220
0
                  break;
17221
646
              }
17222
0
            break;
17223
293
          case 0x02:
17224
293
              GETBYTE ();
17225
293
              switch (op[2] & 0x00)
17226
293
              {
17227
293
                case 0x00:
17228
293
                  goto op_semantics_141;
17229
0
                  break;
17230
293
              }
17231
0
            break;
17232
872
          case 0x03:
17233
872
              GETBYTE ();
17234
872
              switch (op[2] & 0x00)
17235
872
              {
17236
872
                case 0x00:
17237
872
                  goto op_semantics_141;
17238
0
                  break;
17239
872
              }
17240
0
            break;
17241
60
          case 0x04:
17242
60
              GETBYTE ();
17243
60
              switch (op[2] & 0x00)
17244
60
              {
17245
60
                case 0x00:
17246
60
                  goto op_semantics_141;
17247
0
                  break;
17248
60
              }
17249
0
            break;
17250
670
          case 0x05:
17251
670
              GETBYTE ();
17252
670
              switch (op[2] & 0x00)
17253
670
              {
17254
670
                case 0x00:
17255
670
                  goto op_semantics_141;
17256
0
                  break;
17257
670
              }
17258
0
            break;
17259
1.84k
          case 0x06:
17260
1.84k
              GETBYTE ();
17261
1.84k
              switch (op[2] & 0x00)
17262
1.84k
              {
17263
1.84k
                case 0x00:
17264
1.84k
                  goto op_semantics_141;
17265
0
                  break;
17266
1.84k
              }
17267
0
            break;
17268
238
          case 0x07:
17269
238
              GETBYTE ();
17270
238
              switch (op[2] & 0x00)
17271
238
              {
17272
238
                case 0x00:
17273
238
                  goto op_semantics_141;
17274
0
                  break;
17275
238
              }
17276
0
            break;
17277
377
          case 0x08:
17278
377
              GETBYTE ();
17279
377
              switch (op[2] & 0x00)
17280
377
              {
17281
377
                case 0x00:
17282
377
                  goto op_semantics_141;
17283
0
                  break;
17284
377
              }
17285
0
            break;
17286
156
          case 0x09:
17287
156
              GETBYTE ();
17288
156
              switch (op[2] & 0x00)
17289
156
              {
17290
156
                case 0x00:
17291
156
                  goto op_semantics_141;
17292
0
                  break;
17293
156
              }
17294
0
            break;
17295
141
          case 0x0a:
17296
141
              GETBYTE ();
17297
141
              switch (op[2] & 0x00)
17298
141
              {
17299
141
                case 0x00:
17300
141
                  goto op_semantics_141;
17301
0
                  break;
17302
141
              }
17303
0
            break;
17304
352
          case 0x0b:
17305
352
              GETBYTE ();
17306
352
              switch (op[2] & 0x00)
17307
352
              {
17308
352
                case 0x00:
17309
352
                  goto op_semantics_141;
17310
0
                  break;
17311
352
              }
17312
0
            break;
17313
473
          case 0x0c:
17314
473
              GETBYTE ();
17315
473
              switch (op[2] & 0x00)
17316
473
              {
17317
473
                case 0x00:
17318
473
                  goto op_semantics_141;
17319
0
                  break;
17320
473
              }
17321
0
            break;
17322
1.31k
          case 0x0d:
17323
1.31k
              GETBYTE ();
17324
1.31k
              switch (op[2] & 0x00)
17325
1.31k
              {
17326
1.31k
                case 0x00:
17327
1.31k
                  goto op_semantics_141;
17328
0
                  break;
17329
1.31k
              }
17330
0
            break;
17331
107
          case 0x0e:
17332
107
              GETBYTE ();
17333
107
              switch (op[2] & 0x00)
17334
107
              {
17335
107
                case 0x00:
17336
107
                  goto op_semantics_141;
17337
0
                  break;
17338
107
              }
17339
0
            break;
17340
482
          case 0x0f:
17341
482
              GETBYTE ();
17342
482
              switch (op[2] & 0x00)
17343
482
              {
17344
482
                case 0x00:
17345
482
                  goto op_semantics_141;
17346
0
                  break;
17347
482
              }
17348
0
            break;
17349
261
          case 0x10:
17350
261
              GETBYTE ();
17351
261
              switch (op[2] & 0x00)
17352
261
              {
17353
261
                case 0x00:
17354
261
                  goto op_semantics_141;
17355
0
                  break;
17356
261
              }
17357
0
            break;
17358
151
          case 0x11:
17359
151
              GETBYTE ();
17360
151
              switch (op[2] & 0x00)
17361
151
              {
17362
151
                case 0x00:
17363
151
                  goto op_semantics_141;
17364
0
                  break;
17365
151
              }
17366
0
            break;
17367
170
          case 0x12:
17368
170
              GETBYTE ();
17369
170
              switch (op[2] & 0x00)
17370
170
              {
17371
170
                case 0x00:
17372
170
                  goto op_semantics_141;
17373
0
                  break;
17374
170
              }
17375
0
            break;
17376
542
          case 0x13:
17377
542
              GETBYTE ();
17378
542
              switch (op[2] & 0x00)
17379
542
              {
17380
542
                case 0x00:
17381
542
                  goto op_semantics_141;
17382
0
                  break;
17383
542
              }
17384
0
            break;
17385
77
          case 0x14:
17386
77
              GETBYTE ();
17387
77
              switch (op[2] & 0x00)
17388
77
              {
17389
67
                case 0x00:
17390
67
                  goto op_semantics_141;
17391
0
                  break;
17392
77
              }
17393
0
            break;
17394
94
          case 0x15:
17395
94
              GETBYTE ();
17396
94
              switch (op[2] & 0x00)
17397
94
              {
17398
94
                case 0x00:
17399
94
                  goto op_semantics_141;
17400
0
                  break;
17401
94
              }
17402
0
            break;
17403
55
          case 0x16:
17404
55
              GETBYTE ();
17405
55
              switch (op[2] & 0x00)
17406
55
              {
17407
55
                case 0x00:
17408
55
                  goto op_semantics_141;
17409
0
                  break;
17410
55
              }
17411
0
            break;
17412
28
          case 0x17:
17413
28
              GETBYTE ();
17414
28
              switch (op[2] & 0x00)
17415
28
              {
17416
28
                case 0x00:
17417
28
                  goto op_semantics_141;
17418
0
                  break;
17419
28
              }
17420
0
            break;
17421
473
          case 0x18:
17422
473
              GETBYTE ();
17423
473
              switch (op[2] & 0x00)
17424
473
              {
17425
473
                case 0x00:
17426
473
                  goto op_semantics_141;
17427
0
                  break;
17428
473
              }
17429
0
            break;
17430
572
          case 0x19:
17431
572
              GETBYTE ();
17432
572
              switch (op[2] & 0x00)
17433
572
              {
17434
572
                case 0x00:
17435
572
                  goto op_semantics_141;
17436
0
                  break;
17437
572
              }
17438
0
            break;
17439
33
          case 0x1a:
17440
33
              GETBYTE ();
17441
33
              switch (op[2] & 0x00)
17442
33
              {
17443
33
                case 0x00:
17444
33
                  goto op_semantics_141;
17445
0
                  break;
17446
33
              }
17447
0
            break;
17448
18
          case 0x1b:
17449
18
              GETBYTE ();
17450
18
              switch (op[2] & 0x00)
17451
18
              {
17452
18
                case 0x00:
17453
18
                  goto op_semantics_141;
17454
0
                  break;
17455
18
              }
17456
0
            break;
17457
104
          case 0x1c:
17458
104
              GETBYTE ();
17459
104
              switch (op[2] & 0x00)
17460
104
              {
17461
104
                case 0x00:
17462
104
                  goto op_semantics_141;
17463
0
                  break;
17464
104
              }
17465
0
            break;
17466
11
          case 0x1d:
17467
11
              GETBYTE ();
17468
11
              switch (op[2] & 0x00)
17469
11
              {
17470
11
                case 0x00:
17471
11
                  goto op_semantics_141;
17472
0
                  break;
17473
11
              }
17474
0
            break;
17475
127
          case 0x1e:
17476
127
              GETBYTE ();
17477
127
              switch (op[2] & 0x00)
17478
127
              {
17479
124
                case 0x00:
17480
124
                  goto op_semantics_141;
17481
0
                  break;
17482
127
              }
17483
0
            break;
17484
61
          case 0x1f:
17485
61
              GETBYTE ();
17486
61
              switch (op[2] & 0x00)
17487
61
              {
17488
61
                case 0x00:
17489
61
                  goto op_semantics_141;
17490
0
                  break;
17491
61
              }
17492
0
            break;
17493
75
          case 0x20:
17494
75
              GETBYTE ();
17495
75
              switch (op[2] & 0x00)
17496
75
              {
17497
74
                case 0x00:
17498
74
                  goto op_semantics_141;
17499
0
                  break;
17500
75
              }
17501
0
            break;
17502
163
          case 0x21:
17503
163
              GETBYTE ();
17504
163
              switch (op[2] & 0x00)
17505
163
              {
17506
163
                case 0x00:
17507
163
                  goto op_semantics_141;
17508
0
                  break;
17509
163
              }
17510
0
            break;
17511
12
          case 0x22:
17512
12
              GETBYTE ();
17513
12
              switch (op[2] & 0x00)
17514
12
              {
17515
12
                case 0x00:
17516
12
                  goto op_semantics_141;
17517
0
                  break;
17518
12
              }
17519
0
            break;
17520
229
          case 0x23:
17521
229
              GETBYTE ();
17522
229
              switch (op[2] & 0x00)
17523
229
              {
17524
229
                case 0x00:
17525
229
                  goto op_semantics_141;
17526
0
                  break;
17527
229
              }
17528
0
            break;
17529
31
          case 0x24:
17530
31
              GETBYTE ();
17531
31
              switch (op[2] & 0x00)
17532
31
              {
17533
31
                case 0x00:
17534
31
                  goto op_semantics_141;
17535
0
                  break;
17536
31
              }
17537
0
            break;
17538
97
          case 0x25:
17539
97
              GETBYTE ();
17540
97
              switch (op[2] & 0x00)
17541
97
              {
17542
97
                case 0x00:
17543
97
                  goto op_semantics_141;
17544
0
                  break;
17545
97
              }
17546
0
            break;
17547
53
          case 0x26:
17548
53
              GETBYTE ();
17549
53
              switch (op[2] & 0x00)
17550
53
              {
17551
53
                case 0x00:
17552
53
                  goto op_semantics_141;
17553
0
                  break;
17554
53
              }
17555
0
            break;
17556
662
          case 0x27:
17557
662
              GETBYTE ();
17558
662
              switch (op[2] & 0x00)
17559
662
              {
17560
662
                case 0x00:
17561
662
                  goto op_semantics_141;
17562
0
                  break;
17563
662
              }
17564
0
            break;
17565
83
          case 0x28:
17566
83
              GETBYTE ();
17567
83
              switch (op[2] & 0x00)
17568
83
              {
17569
83
                case 0x00:
17570
83
                  goto op_semantics_141;
17571
0
                  break;
17572
83
              }
17573
0
            break;
17574
567
          case 0x29:
17575
567
              GETBYTE ();
17576
567
              switch (op[2] & 0x00)
17577
567
              {
17578
567
                case 0x00:
17579
567
                  goto op_semantics_141;
17580
0
                  break;
17581
567
              }
17582
0
            break;
17583
468
          case 0x2a:
17584
468
              GETBYTE ();
17585
468
              switch (op[2] & 0x00)
17586
468
              {
17587
468
                case 0x00:
17588
468
                  goto op_semantics_141;
17589
0
                  break;
17590
468
              }
17591
0
            break;
17592
242
          case 0x2b:
17593
242
              GETBYTE ();
17594
242
              switch (op[2] & 0x00)
17595
242
              {
17596
242
                case 0x00:
17597
242
                  goto op_semantics_141;
17598
0
                  break;
17599
242
              }
17600
0
            break;
17601
86
          case 0x2c:
17602
86
              GETBYTE ();
17603
86
              switch (op[2] & 0x00)
17604
86
              {
17605
86
                case 0x00:
17606
86
                  goto op_semantics_141;
17607
0
                  break;
17608
86
              }
17609
0
            break;
17610
52
          case 0x2d:
17611
52
              GETBYTE ();
17612
52
              switch (op[2] & 0x00)
17613
52
              {
17614
52
                case 0x00:
17615
52
                  goto op_semantics_141;
17616
0
                  break;
17617
52
              }
17618
0
            break;
17619
137
          case 0x2e:
17620
137
              GETBYTE ();
17621
137
              switch (op[2] & 0x00)
17622
137
              {
17623
137
                case 0x00:
17624
137
                  goto op_semantics_141;
17625
0
                  break;
17626
137
              }
17627
0
            break;
17628
38
          case 0x2f:
17629
38
              GETBYTE ();
17630
38
              switch (op[2] & 0x00)
17631
38
              {
17632
38
                case 0x00:
17633
38
                  goto op_semantics_141;
17634
0
                  break;
17635
38
              }
17636
0
            break;
17637
102
          case 0x40:
17638
102
              GETBYTE ();
17639
102
              switch (op[2] & 0x00)
17640
102
              {
17641
102
                case 0x00:
17642
7.41k
                  op_semantics_142:
17643
7.41k
                    {
17644
                      /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
17645
7.41k
#line 360 "rx-decode.opc"
17646
7.41k
                      int sz AU = (op[1] >> 4) & 0x03;
17647
7.41k
#line 360 "rx-decode.opc"
17648
7.41k
                      int isrc AU = op[1] & 0x0f;
17649
7.41k
#line 360 "rx-decode.opc"
17650
7.41k
                      int bsrc AU = (op[2] >> 4) & 0x0f;
17651
7.41k
#line 360 "rx-decode.opc"
17652
7.41k
                      int rdst AU = op[2] & 0x0f;
17653
7.41k
                      if (trace)
17654
0
                        {
17655
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17656
0
                                 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
17657
0
                                 op[0], op[1], op[2]);
17658
0
                          printf ("  sz = 0x%x,", sz);
17659
0
                          printf ("  isrc = 0x%x,", isrc);
17660
0
                          printf ("  bsrc = 0x%x,", bsrc);
17661
0
                          printf ("  rdst = 0x%x\n", rdst);
17662
0
                        }
17663
7.41k
                      SYNTAX("mov%s [%1, %2], %0");
17664
7.41k
#line 360 "rx-decode.opc"
17665
7.41k
                      ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17666
17667
7.41k
                    }
17668
7.41k
                  break;
17669
102
              }
17670
7.41k
            break;
17671
7.41k
          case 0x41:
17672
35
              GETBYTE ();
17673
35
              switch (op[2] & 0x00)
17674
35
              {
17675
35
                case 0x00:
17676
35
                  goto op_semantics_142;
17677
0
                  break;
17678
35
              }
17679
0
            break;
17680
180
          case 0x42:
17681
180
              GETBYTE ();
17682
180
              switch (op[2] & 0x00)
17683
180
              {
17684
180
                case 0x00:
17685
180
                  goto op_semantics_142;
17686
0
                  break;
17687
180
              }
17688
0
            break;
17689
18
          case 0x43:
17690
18
              GETBYTE ();
17691
18
              switch (op[2] & 0x00)
17692
18
              {
17693
18
                case 0x00:
17694
18
                  goto op_semantics_142;
17695
0
                  break;
17696
18
              }
17697
0
            break;
17698
212
          case 0x44:
17699
212
              GETBYTE ();
17700
212
              switch (op[2] & 0x00)
17701
212
              {
17702
212
                case 0x00:
17703
212
                  goto op_semantics_142;
17704
0
                  break;
17705
212
              }
17706
0
            break;
17707
160
          case 0x45:
17708
160
              GETBYTE ();
17709
160
              switch (op[2] & 0x00)
17710
160
              {
17711
160
                case 0x00:
17712
160
                  goto op_semantics_142;
17713
0
                  break;
17714
160
              }
17715
0
            break;
17716
42
          case 0x46:
17717
42
              GETBYTE ();
17718
42
              switch (op[2] & 0x00)
17719
42
              {
17720
42
                case 0x00:
17721
42
                  goto op_semantics_142;
17722
0
                  break;
17723
42
              }
17724
0
            break;
17725
31
          case 0x47:
17726
31
              GETBYTE ();
17727
31
              switch (op[2] & 0x00)
17728
31
              {
17729
31
                case 0x00:
17730
31
                  goto op_semantics_142;
17731
0
                  break;
17732
31
              }
17733
0
            break;
17734
257
          case 0x48:
17735
257
              GETBYTE ();
17736
257
              switch (op[2] & 0x00)
17737
257
              {
17738
257
                case 0x00:
17739
257
                  goto op_semantics_142;
17740
0
                  break;
17741
257
              }
17742
0
            break;
17743
465
          case 0x49:
17744
465
              GETBYTE ();
17745
465
              switch (op[2] & 0x00)
17746
465
              {
17747
465
                case 0x00:
17748
465
                  goto op_semantics_142;
17749
0
                  break;
17750
465
              }
17751
0
            break;
17752
256
          case 0x4a:
17753
256
              GETBYTE ();
17754
256
              switch (op[2] & 0x00)
17755
256
              {
17756
256
                case 0x00:
17757
256
                  goto op_semantics_142;
17758
0
                  break;
17759
256
              }
17760
0
            break;
17761
137
          case 0x4b:
17762
137
              GETBYTE ();
17763
137
              switch (op[2] & 0x00)
17764
137
              {
17765
137
                case 0x00:
17766
137
                  goto op_semantics_142;
17767
0
                  break;
17768
137
              }
17769
0
            break;
17770
138
          case 0x4c:
17771
138
              GETBYTE ();
17772
138
              switch (op[2] & 0x00)
17773
138
              {
17774
138
                case 0x00:
17775
138
                  goto op_semantics_142;
17776
0
                  break;
17777
138
              }
17778
0
            break;
17779
60
          case 0x4d:
17780
60
              GETBYTE ();
17781
60
              switch (op[2] & 0x00)
17782
60
              {
17783
60
                case 0x00:
17784
60
                  goto op_semantics_142;
17785
0
                  break;
17786
60
              }
17787
0
            break;
17788
149
          case 0x4e:
17789
149
              GETBYTE ();
17790
149
              switch (op[2] & 0x00)
17791
149
              {
17792
149
                case 0x00:
17793
149
                  goto op_semantics_142;
17794
0
                  break;
17795
149
              }
17796
0
            break;
17797
342
          case 0x4f:
17798
342
              GETBYTE ();
17799
342
              switch (op[2] & 0x00)
17800
342
              {
17801
342
                case 0x00:
17802
342
                  goto op_semantics_142;
17803
0
                  break;
17804
342
              }
17805
0
            break;
17806
34
          case 0x50:
17807
34
              GETBYTE ();
17808
34
              switch (op[2] & 0x00)
17809
34
              {
17810
34
                case 0x00:
17811
34
                  goto op_semantics_142;
17812
0
                  break;
17813
34
              }
17814
0
            break;
17815
84
          case 0x51:
17816
84
              GETBYTE ();
17817
84
              switch (op[2] & 0x00)
17818
84
              {
17819
84
                case 0x00:
17820
84
                  goto op_semantics_142;
17821
0
                  break;
17822
84
              }
17823
0
            break;
17824
322
          case 0x52:
17825
322
              GETBYTE ();
17826
322
              switch (op[2] & 0x00)
17827
322
              {
17828
322
                case 0x00:
17829
322
                  goto op_semantics_142;
17830
0
                  break;
17831
322
              }
17832
0
            break;
17833
42
          case 0x53:
17834
42
              GETBYTE ();
17835
42
              switch (op[2] & 0x00)
17836
42
              {
17837
42
                case 0x00:
17838
42
                  goto op_semantics_142;
17839
0
                  break;
17840
42
              }
17841
0
            break;
17842
133
          case 0x54:
17843
133
              GETBYTE ();
17844
133
              switch (op[2] & 0x00)
17845
133
              {
17846
133
                case 0x00:
17847
133
                  goto op_semantics_142;
17848
0
                  break;
17849
133
              }
17850
0
            break;
17851
62
          case 0x55:
17852
62
              GETBYTE ();
17853
62
              switch (op[2] & 0x00)
17854
62
              {
17855
62
                case 0x00:
17856
62
                  goto op_semantics_142;
17857
0
                  break;
17858
62
              }
17859
0
            break;
17860
222
          case 0x56:
17861
222
              GETBYTE ();
17862
222
              switch (op[2] & 0x00)
17863
222
              {
17864
222
                case 0x00:
17865
222
                  goto op_semantics_142;
17866
0
                  break;
17867
222
              }
17868
0
            break;
17869
322
          case 0x57:
17870
322
              GETBYTE ();
17871
322
              switch (op[2] & 0x00)
17872
322
              {
17873
322
                case 0x00:
17874
322
                  goto op_semantics_142;
17875
0
                  break;
17876
322
              }
17877
0
            break;
17878
75
          case 0x58:
17879
75
              GETBYTE ();
17880
75
              switch (op[2] & 0x00)
17881
75
              {
17882
75
                case 0x00:
17883
75
                  goto op_semantics_142;
17884
0
                  break;
17885
75
              }
17886
0
            break;
17887
296
          case 0x59:
17888
296
              GETBYTE ();
17889
296
              switch (op[2] & 0x00)
17890
296
              {
17891
296
                case 0x00:
17892
296
                  goto op_semantics_142;
17893
0
                  break;
17894
296
              }
17895
0
            break;
17896
32
          case 0x5a:
17897
32
              GETBYTE ();
17898
32
              switch (op[2] & 0x00)
17899
32
              {
17900
32
                case 0x00:
17901
32
                  goto op_semantics_142;
17902
0
                  break;
17903
32
              }
17904
0
            break;
17905
72
          case 0x5b:
17906
72
              GETBYTE ();
17907
72
              switch (op[2] & 0x00)
17908
72
              {
17909
72
                case 0x00:
17910
72
                  goto op_semantics_142;
17911
0
                  break;
17912
72
              }
17913
0
            break;
17914
23
          case 0x5c:
17915
23
              GETBYTE ();
17916
23
              switch (op[2] & 0x00)
17917
23
              {
17918
23
                case 0x00:
17919
23
                  goto op_semantics_142;
17920
0
                  break;
17921
23
              }
17922
0
            break;
17923
127
          case 0x5d:
17924
127
              GETBYTE ();
17925
127
              switch (op[2] & 0x00)
17926
127
              {
17927
127
                case 0x00:
17928
127
                  goto op_semantics_142;
17929
0
                  break;
17930
127
              }
17931
0
            break;
17932
921
          case 0x5e:
17933
921
              GETBYTE ();
17934
921
              switch (op[2] & 0x00)
17935
921
              {
17936
921
                case 0x00:
17937
921
                  goto op_semantics_142;
17938
0
                  break;
17939
921
              }
17940
0
            break;
17941
8
          case 0x5f:
17942
8
              GETBYTE ();
17943
8
              switch (op[2] & 0x00)
17944
8
              {
17945
8
                case 0x00:
17946
8
                  goto op_semantics_142;
17947
0
                  break;
17948
8
              }
17949
0
            break;
17950
100
          case 0x60:
17951
100
              GETBYTE ();
17952
100
              switch (op[2] & 0x00)
17953
100
              {
17954
100
                case 0x00:
17955
100
                  goto op_semantics_142;
17956
0
                  break;
17957
100
              }
17958
0
            break;
17959
311
          case 0x61:
17960
311
              GETBYTE ();
17961
311
              switch (op[2] & 0x00)
17962
311
              {
17963
311
                case 0x00:
17964
311
                  goto op_semantics_142;
17965
0
                  break;
17966
311
              }
17967
0
            break;
17968
180
          case 0x62:
17969
180
              GETBYTE ();
17970
180
              switch (op[2] & 0x00)
17971
180
              {
17972
178
                case 0x00:
17973
178
                  goto op_semantics_142;
17974
0
                  break;
17975
180
              }
17976
0
            break;
17977
23
          case 0x63:
17978
23
              GETBYTE ();
17979
23
              switch (op[2] & 0x00)
17980
23
              {
17981
23
                case 0x00:
17982
23
                  goto op_semantics_142;
17983
0
                  break;
17984
23
              }
17985
0
            break;
17986
260
          case 0x64:
17987
260
              GETBYTE ();
17988
260
              switch (op[2] & 0x00)
17989
260
              {
17990
260
                case 0x00:
17991
260
                  goto op_semantics_142;
17992
0
                  break;
17993
260
              }
17994
0
            break;
17995
47
          case 0x65:
17996
47
              GETBYTE ();
17997
47
              switch (op[2] & 0x00)
17998
47
              {
17999
47
                case 0x00:
18000
47
                  goto op_semantics_142;
18001
0
                  break;
18002
47
              }
18003
0
            break;
18004
39
          case 0x66:
18005
39
              GETBYTE ();
18006
39
              switch (op[2] & 0x00)
18007
39
              {
18008
39
                case 0x00:
18009
39
                  goto op_semantics_142;
18010
0
                  break;
18011
39
              }
18012
0
            break;
18013
25
          case 0x67:
18014
25
              GETBYTE ();
18015
25
              switch (op[2] & 0x00)
18016
25
              {
18017
25
                case 0x00:
18018
25
                  goto op_semantics_142;
18019
0
                  break;
18020
25
              }
18021
0
            break;
18022
330
          case 0x68:
18023
330
              GETBYTE ();
18024
330
              switch (op[2] & 0x00)
18025
330
              {
18026
330
                case 0x00:
18027
330
                  goto op_semantics_142;
18028
0
                  break;
18029
330
              }
18030
0
            break;
18031
103
          case 0x69:
18032
103
              GETBYTE ();
18033
103
              switch (op[2] & 0x00)
18034
103
              {
18035
103
                case 0x00:
18036
103
                  goto op_semantics_142;
18037
0
                  break;
18038
103
              }
18039
0
            break;
18040
54
          case 0x6a:
18041
54
              GETBYTE ();
18042
54
              switch (op[2] & 0x00)
18043
54
              {
18044
54
                case 0x00:
18045
54
                  goto op_semantics_142;
18046
0
                  break;
18047
54
              }
18048
0
            break;
18049
186
          case 0x6b:
18050
186
              GETBYTE ();
18051
186
              switch (op[2] & 0x00)
18052
186
              {
18053
186
                case 0x00:
18054
186
                  goto op_semantics_142;
18055
0
                  break;
18056
186
              }
18057
0
            break;
18058
113
          case 0x6c:
18059
113
              GETBYTE ();
18060
113
              switch (op[2] & 0x00)
18061
113
              {
18062
113
                case 0x00:
18063
113
                  goto op_semantics_142;
18064
0
                  break;
18065
113
              }
18066
0
            break;
18067
136
          case 0x6d:
18068
136
              GETBYTE ();
18069
136
              switch (op[2] & 0x00)
18070
136
              {
18071
136
                case 0x00:
18072
136
                  goto op_semantics_142;
18073
0
                  break;
18074
136
              }
18075
0
            break;
18076
55
          case 0x6e:
18077
55
              GETBYTE ();
18078
55
              switch (op[2] & 0x00)
18079
55
              {
18080
53
                case 0x00:
18081
53
                  goto op_semantics_142;
18082
0
                  break;
18083
55
              }
18084
0
            break;
18085
99
          case 0x6f:
18086
99
              GETBYTE ();
18087
99
              switch (op[2] & 0x00)
18088
99
              {
18089
99
                case 0x00:
18090
99
                  goto op_semantics_142;
18091
0
                  break;
18092
99
              }
18093
0
            break;
18094
188
          case 0xc0:
18095
188
              GETBYTE ();
18096
188
              switch (op[2] & 0x00)
18097
188
              {
18098
188
                case 0x00:
18099
8.48k
                  op_semantics_143:
18100
8.48k
                    {
18101
                      /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
18102
8.48k
#line 366 "rx-decode.opc"
18103
8.48k
                      int sz AU = (op[1] >> 4) & 0x03;
18104
8.48k
#line 366 "rx-decode.opc"
18105
8.48k
                      int isrc AU = op[1] & 0x0f;
18106
8.48k
#line 366 "rx-decode.opc"
18107
8.48k
                      int bsrc AU = (op[2] >> 4) & 0x0f;
18108
8.48k
#line 366 "rx-decode.opc"
18109
8.48k
                      int rdst AU = op[2] & 0x0f;
18110
8.48k
                      if (trace)
18111
0
                        {
18112
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18113
0
                                 "/** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */",
18114
0
                                 op[0], op[1], op[2]);
18115
0
                          printf ("  sz = 0x%x,", sz);
18116
0
                          printf ("  isrc = 0x%x,", isrc);
18117
0
                          printf ("  bsrc = 0x%x,", bsrc);
18118
0
                          printf ("  rdst = 0x%x\n", rdst);
18119
0
                        }
18120
8.48k
                      SYNTAX("movu%s  [%1, %2], %0");
18121
8.48k
#line 366 "rx-decode.opc"
18122
8.48k
                      ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
18123
18124
8.48k
                    }
18125
8.48k
                  break;
18126
188
              }
18127
8.48k
            break;
18128
8.48k
          case 0xc1:
18129
863
              GETBYTE ();
18130
863
              switch (op[2] & 0x00)
18131
863
              {
18132
860
                case 0x00:
18133
860
                  goto op_semantics_143;
18134
0
                  break;
18135
863
              }
18136
0
            break;
18137
20
          case 0xc2:
18138
20
              GETBYTE ();
18139
20
              switch (op[2] & 0x00)
18140
20
              {
18141
20
                case 0x00:
18142
20
                  goto op_semantics_143;
18143
0
                  break;
18144
20
              }
18145
0
            break;
18146
42
          case 0xc3:
18147
42
              GETBYTE ();
18148
42
              switch (op[2] & 0x00)
18149
42
              {
18150
42
                case 0x00:
18151
42
                  goto op_semantics_143;
18152
0
                  break;
18153
42
              }
18154
0
            break;
18155
73
          case 0xc4:
18156
73
              GETBYTE ();
18157
73
              switch (op[2] & 0x00)
18158
73
              {
18159
73
                case 0x00:
18160
73
                  goto op_semantics_143;
18161
0
                  break;
18162
73
              }
18163
0
            break;
18164
109
          case 0xc5:
18165
109
              GETBYTE ();
18166
109
              switch (op[2] & 0x00)
18167
109
              {
18168
109
                case 0x00:
18169
109
                  goto op_semantics_143;
18170
0
                  break;
18171
109
              }
18172
0
            break;
18173
101
          case 0xc6:
18174
101
              GETBYTE ();
18175
101
              switch (op[2] & 0x00)
18176
101
              {
18177
101
                case 0x00:
18178
101
                  goto op_semantics_143;
18179
0
                  break;
18180
101
              }
18181
0
            break;
18182
104
          case 0xc7:
18183
104
              GETBYTE ();
18184
104
              switch (op[2] & 0x00)
18185
104
              {
18186
104
                case 0x00:
18187
104
                  goto op_semantics_143;
18188
0
                  break;
18189
104
              }
18190
0
            break;
18191
89
          case 0xc8:
18192
89
              GETBYTE ();
18193
89
              switch (op[2] & 0x00)
18194
89
              {
18195
89
                case 0x00:
18196
89
                  goto op_semantics_143;
18197
0
                  break;
18198
89
              }
18199
0
            break;
18200
106
          case 0xc9:
18201
106
              GETBYTE ();
18202
106
              switch (op[2] & 0x00)
18203
106
              {
18204
106
                case 0x00:
18205
106
                  goto op_semantics_143;
18206
0
                  break;
18207
106
              }
18208
0
            break;
18209
339
          case 0xca:
18210
339
              GETBYTE ();
18211
339
              switch (op[2] & 0x00)
18212
339
              {
18213
339
                case 0x00:
18214
339
                  goto op_semantics_143;
18215
0
                  break;
18216
339
              }
18217
0
            break;
18218
71
          case 0xcb:
18219
71
              GETBYTE ();
18220
71
              switch (op[2] & 0x00)
18221
71
              {
18222
63
                case 0x00:
18223
63
                  goto op_semantics_143;
18224
0
                  break;
18225
71
              }
18226
0
            break;
18227
336
          case 0xcc:
18228
336
              GETBYTE ();
18229
336
              switch (op[2] & 0x00)
18230
336
              {
18231
336
                case 0x00:
18232
336
                  goto op_semantics_143;
18233
0
                  break;
18234
336
              }
18235
0
            break;
18236
13
          case 0xcd:
18237
13
              GETBYTE ();
18238
13
              switch (op[2] & 0x00)
18239
13
              {
18240
13
                case 0x00:
18241
13
                  goto op_semantics_143;
18242
0
                  break;
18243
13
              }
18244
0
            break;
18245
134
          case 0xce:
18246
134
              GETBYTE ();
18247
134
              switch (op[2] & 0x00)
18248
134
              {
18249
134
                case 0x00:
18250
134
                  goto op_semantics_143;
18251
0
                  break;
18252
134
              }
18253
0
            break;
18254
552
          case 0xcf:
18255
552
              GETBYTE ();
18256
552
              switch (op[2] & 0x00)
18257
552
              {
18258
552
                case 0x00:
18259
552
                  goto op_semantics_143;
18260
0
                  break;
18261
552
              }
18262
0
            break;
18263
67
          case 0xd0:
18264
67
              GETBYTE ();
18265
67
              switch (op[2] & 0x00)
18266
67
              {
18267
67
                case 0x00:
18268
67
                  goto op_semantics_143;
18269
0
                  break;
18270
67
              }
18271
0
            break;
18272
258
          case 0xd1:
18273
258
              GETBYTE ();
18274
258
              switch (op[2] & 0x00)
18275
258
              {
18276
258
                case 0x00:
18277
258
                  goto op_semantics_143;
18278
0
                  break;
18279
258
              }
18280
0
            break;
18281
56
          case 0xd2:
18282
56
              GETBYTE ();
18283
56
              switch (op[2] & 0x00)
18284
56
              {
18285
56
                case 0x00:
18286
56
                  goto op_semantics_143;
18287
0
                  break;
18288
56
              }
18289
0
            break;
18290
61
          case 0xd3:
18291
61
              GETBYTE ();
18292
61
              switch (op[2] & 0x00)
18293
61
              {
18294
61
                case 0x00:
18295
61
                  goto op_semantics_143;
18296
0
                  break;
18297
61
              }
18298
0
            break;
18299
99
          case 0xd4:
18300
99
              GETBYTE ();
18301
99
              switch (op[2] & 0x00)
18302
99
              {
18303
99
                case 0x00:
18304
99
                  goto op_semantics_143;
18305
0
                  break;
18306
99
              }
18307
0
            break;
18308
26
          case 0xd5:
18309
26
              GETBYTE ();
18310
26
              switch (op[2] & 0x00)
18311
26
              {
18312
24
                case 0x00:
18313
24
                  goto op_semantics_143;
18314
0
                  break;
18315
26
              }
18316
0
            break;
18317
140
          case 0xd6:
18318
140
              GETBYTE ();
18319
140
              switch (op[2] & 0x00)
18320
140
              {
18321
140
                case 0x00:
18322
140
                  goto op_semantics_143;
18323
0
                  break;
18324
140
              }
18325
0
            break;
18326
150
          case 0xd7:
18327
150
              GETBYTE ();
18328
150
              switch (op[2] & 0x00)
18329
150
              {
18330
150
                case 0x00:
18331
150
                  goto op_semantics_143;
18332
0
                  break;
18333
150
              }
18334
0
            break;
18335
123
          case 0xd8:
18336
123
              GETBYTE ();
18337
123
              switch (op[2] & 0x00)
18338
123
              {
18339
123
                case 0x00:
18340
123
                  goto op_semantics_143;
18341
0
                  break;
18342
123
              }
18343
0
            break;
18344
150
          case 0xd9:
18345
150
              GETBYTE ();
18346
150
              switch (op[2] & 0x00)
18347
150
              {
18348
150
                case 0x00:
18349
150
                  goto op_semantics_143;
18350
0
                  break;
18351
150
              }
18352
0
            break;
18353
178
          case 0xda:
18354
178
              GETBYTE ();
18355
178
              switch (op[2] & 0x00)
18356
178
              {
18357
178
                case 0x00:
18358
178
                  goto op_semantics_143;
18359
0
                  break;
18360
178
              }
18361
0
            break;
18362
218
          case 0xdb:
18363
218
              GETBYTE ();
18364
218
              switch (op[2] & 0x00)
18365
218
              {
18366
218
                case 0x00:
18367
218
                  goto op_semantics_143;
18368
0
                  break;
18369
218
              }
18370
0
            break;
18371
217
          case 0xdc:
18372
217
              GETBYTE ();
18373
217
              switch (op[2] & 0x00)
18374
217
              {
18375
217
                case 0x00:
18376
217
                  goto op_semantics_143;
18377
0
                  break;
18378
217
              }
18379
0
            break;
18380
57
          case 0xdd:
18381
57
              GETBYTE ();
18382
57
              switch (op[2] & 0x00)
18383
57
              {
18384
57
                case 0x00:
18385
57
                  goto op_semantics_143;
18386
0
                  break;
18387
57
              }
18388
0
            break;
18389
42
          case 0xde:
18390
42
              GETBYTE ();
18391
42
              switch (op[2] & 0x00)
18392
42
              {
18393
42
                case 0x00:
18394
42
                  goto op_semantics_143;
18395
0
                  break;
18396
42
              }
18397
0
            break;
18398
62
          case 0xdf:
18399
62
              GETBYTE ();
18400
62
              switch (op[2] & 0x00)
18401
62
              {
18402
61
                case 0x00:
18403
61
                  goto op_semantics_143;
18404
0
                  break;
18405
62
              }
18406
0
            break;
18407
115
          case 0xe0:
18408
115
              GETBYTE ();
18409
115
              switch (op[2] & 0x00)
18410
115
              {
18411
115
                case 0x00:
18412
115
                  goto op_semantics_143;
18413
0
                  break;
18414
115
              }
18415
0
            break;
18416
127
          case 0xe1:
18417
127
              GETBYTE ();
18418
127
              switch (op[2] & 0x00)
18419
127
              {
18420
127
                case 0x00:
18421
127
                  goto op_semantics_143;
18422
0
                  break;
18423
127
              }
18424
0
            break;
18425
38
          case 0xe2:
18426
38
              GETBYTE ();
18427
38
              switch (op[2] & 0x00)
18428
38
              {
18429
38
                case 0x00:
18430
38
                  goto op_semantics_143;
18431
0
                  break;
18432
38
              }
18433
0
            break;
18434
113
          case 0xe3:
18435
113
              GETBYTE ();
18436
113
              switch (op[2] & 0x00)
18437
113
              {
18438
113
                case 0x00:
18439
113
                  goto op_semantics_143;
18440
0
                  break;
18441
113
              }
18442
0
            break;
18443
322
          case 0xe4:
18444
322
              GETBYTE ();
18445
322
              switch (op[2] & 0x00)
18446
322
              {
18447
322
                case 0x00:
18448
322
                  goto op_semantics_143;
18449
0
                  break;
18450
322
              }
18451
0
            break;
18452
261
          case 0xe5:
18453
261
              GETBYTE ();
18454
261
              switch (op[2] & 0x00)
18455
261
              {
18456
261
                case 0x00:
18457
261
                  goto op_semantics_143;
18458
0
                  break;
18459
261
              }
18460
0
            break;
18461
64
          case 0xe6:
18462
64
              GETBYTE ();
18463
64
              switch (op[2] & 0x00)
18464
64
              {
18465
64
                case 0x00:
18466
64
                  goto op_semantics_143;
18467
0
                  break;
18468
64
              }
18469
0
            break;
18470
191
          case 0xe7:
18471
191
              GETBYTE ();
18472
191
              switch (op[2] & 0x00)
18473
191
              {
18474
191
                case 0x00:
18475
191
                  goto op_semantics_143;
18476
0
                  break;
18477
191
              }
18478
0
            break;
18479
171
          case 0xe8:
18480
171
              GETBYTE ();
18481
171
              switch (op[2] & 0x00)
18482
171
              {
18483
171
                case 0x00:
18484
171
                  goto op_semantics_143;
18485
0
                  break;
18486
171
              }
18487
0
            break;
18488
7
          case 0xe9:
18489
7
              GETBYTE ();
18490
7
              switch (op[2] & 0x00)
18491
7
              {
18492
7
                case 0x00:
18493
7
                  goto op_semantics_143;
18494
0
                  break;
18495
7
              }
18496
0
            break;
18497
147
          case 0xea:
18498
147
              GETBYTE ();
18499
147
              switch (op[2] & 0x00)
18500
147
              {
18501
147
                case 0x00:
18502
147
                  goto op_semantics_143;
18503
0
                  break;
18504
147
              }
18505
0
            break;
18506
118
          case 0xeb:
18507
118
              GETBYTE ();
18508
118
              switch (op[2] & 0x00)
18509
118
              {
18510
118
                case 0x00:
18511
118
                  goto op_semantics_143;
18512
0
                  break;
18513
118
              }
18514
0
            break;
18515
116
          case 0xec:
18516
116
              GETBYTE ();
18517
116
              switch (op[2] & 0x00)
18518
116
              {
18519
116
                case 0x00:
18520
116
                  goto op_semantics_143;
18521
0
                  break;
18522
116
              }
18523
0
            break;
18524
386
          case 0xed:
18525
386
              GETBYTE ();
18526
386
              switch (op[2] & 0x00)
18527
386
              {
18528
382
                case 0x00:
18529
382
                  goto op_semantics_143;
18530
0
                  break;
18531
386
              }
18532
0
            break;
18533
50
          case 0xee:
18534
50
              GETBYTE ();
18535
50
              switch (op[2] & 0x00)
18536
50
              {
18537
50
                case 0x00:
18538
50
                  goto op_semantics_143;
18539
0
                  break;
18540
50
              }
18541
0
            break;
18542
1.23k
          case 0xef:
18543
1.23k
              GETBYTE ();
18544
1.23k
              switch (op[2] & 0x00)
18545
1.23k
              {
18546
1.23k
                case 0x00:
18547
1.23k
                  goto op_semantics_143;
18548
0
                  break;
18549
1.23k
              }
18550
0
            break;
18551
22.2k
          default: UNSUPPORTED(); break;
18552
56.5k
        }
18553
56.5k
      break;
18554
824k
    case 0xff:
18555
824k
        GETBYTE ();
18556
824k
        switch (op[1] & 0xff)
18557
824k
        {
18558
56.0k
          case 0x00:
18559
56.0k
              GETBYTE ();
18560
56.0k
              switch (op[2] & 0x00)
18561
56.0k
              {
18562
56.0k
                case 0x00:
18563
91.5k
                  op_semantics_144:
18564
91.5k
                    {
18565
                      /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
18566
91.5k
#line 570 "rx-decode.opc"
18567
91.5k
                      int rdst AU = op[1] & 0x0f;
18568
91.5k
#line 570 "rx-decode.opc"
18569
91.5k
                      int srca AU = (op[2] >> 4) & 0x0f;
18570
91.5k
#line 570 "rx-decode.opc"
18571
91.5k
                      int srcb AU = op[2] & 0x0f;
18572
91.5k
                      if (trace)
18573
0
                        {
18574
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18575
0
                                 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
18576
0
                                 op[0], op[1], op[2]);
18577
0
                          printf ("  rdst = 0x%x,", rdst);
18578
0
                          printf ("  srca = 0x%x,", srca);
18579
0
                          printf ("  srcb = 0x%x\n", srcb);
18580
0
                        }
18581
91.5k
                      SYNTAX("sub %2, %1, %0");
18582
91.5k
#line 570 "rx-decode.opc"
18583
91.5k
                      ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18584
18585
                    /*----------------------------------------------------------------------*/
18586
                    /* SBB                  */
18587
18588
91.5k
                    }
18589
91.5k
                  break;
18590
56.0k
              }
18591
91.5k
            break;
18592
91.5k
          case 0x01:
18593
6.75k
              GETBYTE ();
18594
6.75k
              switch (op[2] & 0x00)
18595
6.75k
              {
18596
6.75k
                case 0x00:
18597
6.75k
                  goto op_semantics_144;
18598
0
                  break;
18599
6.75k
              }
18600
0
            break;
18601
2.14k
          case 0x02:
18602
2.14k
              GETBYTE ();
18603
2.14k
              switch (op[2] & 0x00)
18604
2.14k
              {
18605
2.14k
                case 0x00:
18606
2.14k
                  goto op_semantics_144;
18607
0
                  break;
18608
2.14k
              }
18609
0
            break;
18610
1.90k
          case 0x03:
18611
1.90k
              GETBYTE ();
18612
1.90k
              switch (op[2] & 0x00)
18613
1.90k
              {
18614
1.90k
                case 0x00:
18615
1.90k
                  goto op_semantics_144;
18616
0
                  break;
18617
1.90k
              }
18618
0
            break;
18619
1.34k
          case 0x04:
18620
1.34k
              GETBYTE ();
18621
1.34k
              switch (op[2] & 0x00)
18622
1.34k
              {
18623
1.34k
                case 0x00:
18624
1.34k
                  goto op_semantics_144;
18625
0
                  break;
18626
1.34k
              }
18627
0
            break;
18628
1.56k
          case 0x05:
18629
1.56k
              GETBYTE ();
18630
1.56k
              switch (op[2] & 0x00)
18631
1.56k
              {
18632
1.56k
                case 0x00:
18633
1.56k
                  goto op_semantics_144;
18634
0
                  break;
18635
1.56k
              }
18636
0
            break;
18637
2.51k
          case 0x06:
18638
2.51k
              GETBYTE ();
18639
2.51k
              switch (op[2] & 0x00)
18640
2.51k
              {
18641
2.51k
                case 0x00:
18642
2.51k
                  goto op_semantics_144;
18643
0
                  break;
18644
2.51k
              }
18645
0
            break;
18646
1.77k
          case 0x07:
18647
1.77k
              GETBYTE ();
18648
1.77k
              switch (op[2] & 0x00)
18649
1.77k
              {
18650
1.77k
                case 0x00:
18651
1.77k
                  goto op_semantics_144;
18652
0
                  break;
18653
1.77k
              }
18654
0
            break;
18655
1.28k
          case 0x08:
18656
1.28k
              GETBYTE ();
18657
1.28k
              switch (op[2] & 0x00)
18658
1.28k
              {
18659
1.28k
                case 0x00:
18660
1.28k
                  goto op_semantics_144;
18661
0
                  break;
18662
1.28k
              }
18663
0
            break;
18664
1.12k
          case 0x09:
18665
1.12k
              GETBYTE ();
18666
1.12k
              switch (op[2] & 0x00)
18667
1.12k
              {
18668
1.12k
                case 0x00:
18669
1.12k
                  goto op_semantics_144;
18670
0
                  break;
18671
1.12k
              }
18672
0
            break;
18673
810
          case 0x0a:
18674
810
              GETBYTE ();
18675
810
              switch (op[2] & 0x00)
18676
810
              {
18677
810
                case 0x00:
18678
810
                  goto op_semantics_144;
18679
0
                  break;
18680
810
              }
18681
0
            break;
18682
1.16k
          case 0x0b:
18683
1.16k
              GETBYTE ();
18684
1.16k
              switch (op[2] & 0x00)
18685
1.16k
              {
18686
1.16k
                case 0x00:
18687
1.16k
                  goto op_semantics_144;
18688
0
                  break;
18689
1.16k
              }
18690
0
            break;
18691
1.50k
          case 0x0c:
18692
1.50k
              GETBYTE ();
18693
1.50k
              switch (op[2] & 0x00)
18694
1.50k
              {
18695
1.50k
                case 0x00:
18696
1.50k
                  goto op_semantics_144;
18697
0
                  break;
18698
1.50k
              }
18699
0
            break;
18700
1.05k
          case 0x0d:
18701
1.05k
              GETBYTE ();
18702
1.05k
              switch (op[2] & 0x00)
18703
1.05k
              {
18704
1.05k
                case 0x00:
18705
1.05k
                  goto op_semantics_144;
18706
0
                  break;
18707
1.05k
              }
18708
0
            break;
18709
7.90k
          case 0x0e:
18710
7.90k
              GETBYTE ();
18711
7.90k
              switch (op[2] & 0x00)
18712
7.90k
              {
18713
7.88k
                case 0x00:
18714
7.88k
                  goto op_semantics_144;
18715
0
                  break;
18716
7.90k
              }
18717
0
            break;
18718
2.67k
          case 0x0f:
18719
2.67k
              GETBYTE ();
18720
2.67k
              switch (op[2] & 0x00)
18721
2.67k
              {
18722
2.67k
                case 0x00:
18723
2.67k
                  goto op_semantics_144;
18724
0
                  break;
18725
2.67k
              }
18726
0
            break;
18727
689
          case 0x20:
18728
689
              GETBYTE ();
18729
689
              switch (op[2] & 0x00)
18730
689
              {
18731
689
                case 0x00:
18732
10.5k
                  op_semantics_145:
18733
10.5k
                    {
18734
                      /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
18735
10.5k
#line 537 "rx-decode.opc"
18736
10.5k
                      int rdst AU = op[1] & 0x0f;
18737
10.5k
#line 537 "rx-decode.opc"
18738
10.5k
                      int srca AU = (op[2] >> 4) & 0x0f;
18739
10.5k
#line 537 "rx-decode.opc"
18740
10.5k
                      int srcb AU = op[2] & 0x0f;
18741
10.5k
                      if (trace)
18742
0
                        {
18743
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18744
0
                                 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
18745
0
                                 op[0], op[1], op[2]);
18746
0
                          printf ("  rdst = 0x%x,", rdst);
18747
0
                          printf ("  srca = 0x%x,", srca);
18748
0
                          printf ("  srcb = 0x%x\n", srcb);
18749
0
                        }
18750
10.5k
                      SYNTAX("add %2, %1, %0");
18751
10.5k
#line 537 "rx-decode.opc"
18752
10.5k
                      ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18753
18754
                    /*----------------------------------------------------------------------*/
18755
                    /* CMP                  */
18756
18757
10.5k
                    }
18758
10.5k
                  break;
18759
689
              }
18760
10.5k
            break;
18761
10.5k
          case 0x21:
18762
555
              GETBYTE ();
18763
555
              switch (op[2] & 0x00)
18764
555
              {
18765
554
                case 0x00:
18766
554
                  goto op_semantics_145;
18767
0
                  break;
18768
555
              }
18769
0
            break;
18770
557
          case 0x22:
18771
557
              GETBYTE ();
18772
557
              switch (op[2] & 0x00)
18773
557
              {
18774
557
                case 0x00:
18775
557
                  goto op_semantics_145;
18776
0
                  break;
18777
557
              }
18778
0
            break;
18779
1.22k
          case 0x23:
18780
1.22k
              GETBYTE ();
18781
1.22k
              switch (op[2] & 0x00)
18782
1.22k
              {
18783
1.22k
                case 0x00:
18784
1.22k
                  goto op_semantics_145;
18785
0
                  break;
18786
1.22k
              }
18787
0
            break;
18788
438
          case 0x24:
18789
438
              GETBYTE ();
18790
438
              switch (op[2] & 0x00)
18791
438
              {
18792
423
                case 0x00:
18793
423
                  goto op_semantics_145;
18794
0
                  break;
18795
438
              }
18796
0
            break;
18797
425
          case 0x25:
18798
425
              GETBYTE ();
18799
425
              switch (op[2] & 0x00)
18800
425
              {
18801
425
                case 0x00:
18802
425
                  goto op_semantics_145;
18803
0
                  break;
18804
425
              }
18805
0
            break;
18806
550
          case 0x26:
18807
550
              GETBYTE ();
18808
550
              switch (op[2] & 0x00)
18809
550
              {
18810
550
                case 0x00:
18811
550
                  goto op_semantics_145;
18812
0
                  break;
18813
550
              }
18814
0
            break;
18815
596
          case 0x27:
18816
596
              GETBYTE ();
18817
596
              switch (op[2] & 0x00)
18818
596
              {
18819
594
                case 0x00:
18820
594
                  goto op_semantics_145;
18821
0
                  break;
18822
596
              }
18823
0
            break;
18824
528
          case 0x28:
18825
528
              GETBYTE ();
18826
528
              switch (op[2] & 0x00)
18827
528
              {
18828
528
                case 0x00:
18829
528
                  goto op_semantics_145;
18830
0
                  break;
18831
528
              }
18832
0
            break;
18833
892
          case 0x29:
18834
892
              GETBYTE ();
18835
892
              switch (op[2] & 0x00)
18836
892
              {
18837
892
                case 0x00:
18838
892
                  goto op_semantics_145;
18839
0
                  break;
18840
892
              }
18841
0
            break;
18842
456
          case 0x2a:
18843
456
              GETBYTE ();
18844
456
              switch (op[2] & 0x00)
18845
456
              {
18846
456
                case 0x00:
18847
456
                  goto op_semantics_145;
18848
0
                  break;
18849
456
              }
18850
0
            break;
18851
267
          case 0x2b:
18852
267
              GETBYTE ();
18853
267
              switch (op[2] & 0x00)
18854
267
              {
18855
267
                case 0x00:
18856
267
                  goto op_semantics_145;
18857
0
                  break;
18858
267
              }
18859
0
            break;
18860
1.52k
          case 0x2c:
18861
1.52k
              GETBYTE ();
18862
1.52k
              switch (op[2] & 0x00)
18863
1.52k
              {
18864
1.52k
                case 0x00:
18865
1.52k
                  goto op_semantics_145;
18866
0
                  break;
18867
1.52k
              }
18868
0
            break;
18869
496
          case 0x2d:
18870
496
              GETBYTE ();
18871
496
              switch (op[2] & 0x00)
18872
496
              {
18873
496
                case 0x00:
18874
496
                  goto op_semantics_145;
18875
0
                  break;
18876
496
              }
18877
0
            break;
18878
568
          case 0x2e:
18879
568
              GETBYTE ();
18880
568
              switch (op[2] & 0x00)
18881
568
              {
18882
568
                case 0x00:
18883
568
                  goto op_semantics_145;
18884
0
                  break;
18885
568
              }
18886
0
            break;
18887
788
          case 0x2f:
18888
788
              GETBYTE ();
18889
788
              switch (op[2] & 0x00)
18890
788
              {
18891
788
                case 0x00:
18892
788
                  goto op_semantics_145;
18893
0
                  break;
18894
788
              }
18895
0
            break;
18896
1.14k
          case 0x30:
18897
1.14k
              GETBYTE ();
18898
1.14k
              switch (op[2] & 0x00)
18899
1.14k
              {
18900
1.14k
                case 0x00:
18901
14.2k
                  op_semantics_146:
18902
14.2k
                    {
18903
                      /** 1111 1111 0011 rdst srca srcb mul   %2, %1, %0 */
18904
14.2k
#line 677 "rx-decode.opc"
18905
14.2k
                      int rdst AU = op[1] & 0x0f;
18906
14.2k
#line 677 "rx-decode.opc"
18907
14.2k
                      int srca AU = (op[2] >> 4) & 0x0f;
18908
14.2k
#line 677 "rx-decode.opc"
18909
14.2k
                      int srcb AU = op[2] & 0x0f;
18910
14.2k
                      if (trace)
18911
0
                        {
18912
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18913
0
                                 "/** 1111 1111 0011 rdst srca srcb mul   %2, %1, %0 */",
18914
0
                                 op[0], op[1], op[2]);
18915
0
                          printf ("  rdst = 0x%x,", rdst);
18916
0
                          printf ("  srca = 0x%x,", srca);
18917
0
                          printf ("  srcb = 0x%x\n", srcb);
18918
0
                        }
18919
14.2k
                      SYNTAX("mul   %2, %1, %0");
18920
14.2k
#line 677 "rx-decode.opc"
18921
14.2k
                      ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18922
18923
                    /*----------------------------------------------------------------------*/
18924
                    /* EMUL                 */
18925
18926
14.2k
                    }
18927
14.2k
                  break;
18928
1.14k
              }
18929
14.2k
            break;
18930
14.2k
          case 0x31:
18931
618
              GETBYTE ();
18932
618
              switch (op[2] & 0x00)
18933
618
              {
18934
618
                case 0x00:
18935
618
                  goto op_semantics_146;
18936
0
                  break;
18937
618
              }
18938
0
            break;
18939
695
          case 0x32:
18940
695
              GETBYTE ();
18941
695
              switch (op[2] & 0x00)
18942
695
              {
18943
695
                case 0x00:
18944
695
                  goto op_semantics_146;
18945
0
                  break;
18946
695
              }
18947
0
            break;
18948
519
          case 0x33:
18949
519
              GETBYTE ();
18950
519
              switch (op[2] & 0x00)
18951
519
              {
18952
519
                case 0x00:
18953
519
                  goto op_semantics_146;
18954
0
                  break;
18955
519
              }
18956
0
            break;
18957
2.63k
          case 0x34:
18958
2.63k
              GETBYTE ();
18959
2.63k
              switch (op[2] & 0x00)
18960
2.63k
              {
18961
2.63k
                case 0x00:
18962
2.63k
                  goto op_semantics_146;
18963
0
                  break;
18964
2.63k
              }
18965
0
            break;
18966
702
          case 0x35:
18967
702
              GETBYTE ();
18968
702
              switch (op[2] & 0x00)
18969
702
              {
18970
699
                case 0x00:
18971
699
                  goto op_semantics_146;
18972
0
                  break;
18973
702
              }
18974
0
            break;
18975
562
          case 0x36:
18976
562
              GETBYTE ();
18977
562
              switch (op[2] & 0x00)
18978
562
              {
18979
562
                case 0x00:
18980
562
                  goto op_semantics_146;
18981
0
                  break;
18982
562
              }
18983
0
            break;
18984
230
          case 0x37:
18985
230
              GETBYTE ();
18986
230
              switch (op[2] & 0x00)
18987
230
              {
18988
230
                case 0x00:
18989
230
                  goto op_semantics_146;
18990
0
                  break;
18991
230
              }
18992
0
            break;
18993
1.00k
          case 0x38:
18994
1.00k
              GETBYTE ();
18995
1.00k
              switch (op[2] & 0x00)
18996
1.00k
              {
18997
1.00k
                case 0x00:
18998
1.00k
                  goto op_semantics_146;
18999
0
                  break;
19000
1.00k
              }
19001
0
            break;
19002
983
          case 0x39:
19003
983
              GETBYTE ();
19004
983
              switch (op[2] & 0x00)
19005
983
              {
19006
983
                case 0x00:
19007
983
                  goto op_semantics_146;
19008
0
                  break;
19009
983
              }
19010
0
            break;
19011
483
          case 0x3a:
19012
483
              GETBYTE ();
19013
483
              switch (op[2] & 0x00)
19014
483
              {
19015
483
                case 0x00:
19016
483
                  goto op_semantics_146;
19017
0
                  break;
19018
483
              }
19019
0
            break;
19020
1.02k
          case 0x3b:
19021
1.02k
              GETBYTE ();
19022
1.02k
              switch (op[2] & 0x00)
19023
1.02k
              {
19024
1.02k
                case 0x00:
19025
1.02k
                  goto op_semantics_146;
19026
0
                  break;
19027
1.02k
              }
19028
0
            break;
19029
1.27k
          case 0x3c:
19030
1.27k
              GETBYTE ();
19031
1.27k
              switch (op[2] & 0x00)
19032
1.27k
              {
19033
1.27k
                case 0x00:
19034
1.27k
                  goto op_semantics_146;
19035
0
                  break;
19036
1.27k
              }
19037
0
            break;
19038
1.13k
          case 0x3d:
19039
1.13k
              GETBYTE ();
19040
1.13k
              switch (op[2] & 0x00)
19041
1.13k
              {
19042
1.13k
                case 0x00:
19043
1.13k
                  goto op_semantics_146;
19044
0
                  break;
19045
1.13k
              }
19046
0
            break;
19047
358
          case 0x3e:
19048
358
              GETBYTE ();
19049
358
              switch (op[2] & 0x00)
19050
358
              {
19051
358
                case 0x00:
19052
358
                  goto op_semantics_146;
19053
0
                  break;
19054
358
              }
19055
0
            break;
19056
841
          case 0x3f:
19057
841
              GETBYTE ();
19058
841
              switch (op[2] & 0x00)
19059
841
              {
19060
841
                case 0x00:
19061
841
                  goto op_semantics_146;
19062
0
                  break;
19063
841
              }
19064
0
            break;
19065
1.45k
          case 0x40:
19066
1.45k
              GETBYTE ();
19067
1.45k
              switch (op[2] & 0x00)
19068
1.45k
              {
19069
1.44k
                case 0x00:
19070
20.1k
                  op_semantics_147:
19071
20.1k
                    {
19072
                      /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
19073
20.1k
#line 447 "rx-decode.opc"
19074
20.1k
                      int rdst AU = op[1] & 0x0f;
19075
20.1k
#line 447 "rx-decode.opc"
19076
20.1k
                      int srca AU = (op[2] >> 4) & 0x0f;
19077
20.1k
#line 447 "rx-decode.opc"
19078
20.1k
                      int srcb AU = op[2] & 0x0f;
19079
20.1k
                      if (trace)
19080
0
                        {
19081
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19082
0
                                 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
19083
0
                                 op[0], op[1], op[2]);
19084
0
                          printf ("  rdst = 0x%x,", rdst);
19085
0
                          printf ("  srca = 0x%x,", srca);
19086
0
                          printf ("  srcb = 0x%x\n", srcb);
19087
0
                        }
19088
20.1k
                      SYNTAX("and %2, %1, %0");
19089
20.1k
#line 447 "rx-decode.opc"
19090
20.1k
                      ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19091
19092
                    /*----------------------------------------------------------------------*/
19093
                    /* OR                 */
19094
19095
20.1k
                    }
19096
20.1k
                  break;
19097
1.45k
              }
19098
20.1k
            break;
19099
20.1k
          case 0x41:
19100
1.23k
              GETBYTE ();
19101
1.23k
              switch (op[2] & 0x00)
19102
1.23k
              {
19103
1.23k
                case 0x00:
19104
1.23k
                  goto op_semantics_147;
19105
0
                  break;
19106
1.23k
              }
19107
0
            break;
19108
153
          case 0x42:
19109
153
              GETBYTE ();
19110
153
              switch (op[2] & 0x00)
19111
153
              {
19112
153
                case 0x00:
19113
153
                  goto op_semantics_147;
19114
0
                  break;
19115
153
              }
19116
0
            break;
19117
335
          case 0x43:
19118
335
              GETBYTE ();
19119
335
              switch (op[2] & 0x00)
19120
335
              {
19121
335
                case 0x00:
19122
335
                  goto op_semantics_147;
19123
0
                  break;
19124
335
              }
19125
0
            break;
19126
1.41k
          case 0x44:
19127
1.41k
              GETBYTE ();
19128
1.41k
              switch (op[2] & 0x00)
19129
1.41k
              {
19130
1.41k
                case 0x00:
19131
1.41k
                  goto op_semantics_147;
19132
0
                  break;
19133
1.41k
              }
19134
0
            break;
19135
1.09k
          case 0x45:
19136
1.09k
              GETBYTE ();
19137
1.09k
              switch (op[2] & 0x00)
19138
1.09k
              {
19139
1.09k
                case 0x00:
19140
1.09k
                  goto op_semantics_147;
19141
0
                  break;
19142
1.09k
              }
19143
0
            break;
19144
461
          case 0x46:
19145
461
              GETBYTE ();
19146
461
              switch (op[2] & 0x00)
19147
461
              {
19148
440
                case 0x00:
19149
440
                  goto op_semantics_147;
19150
0
                  break;
19151
461
              }
19152
0
            break;
19153
1.07k
          case 0x47:
19154
1.07k
              GETBYTE ();
19155
1.07k
              switch (op[2] & 0x00)
19156
1.07k
              {
19157
1.07k
                case 0x00:
19158
1.07k
                  goto op_semantics_147;
19159
0
                  break;
19160
1.07k
              }
19161
0
            break;
19162
3.77k
          case 0x48:
19163
3.77k
              GETBYTE ();
19164
3.77k
              switch (op[2] & 0x00)
19165
3.77k
              {
19166
3.77k
                case 0x00:
19167
3.77k
                  goto op_semantics_147;
19168
0
                  break;
19169
3.77k
              }
19170
0
            break;
19171
4.45k
          case 0x49:
19172
4.45k
              GETBYTE ();
19173
4.45k
              switch (op[2] & 0x00)
19174
4.45k
              {
19175
4.45k
                case 0x00:
19176
4.45k
                  goto op_semantics_147;
19177
0
                  break;
19178
4.45k
              }
19179
0
            break;
19180
293
          case 0x4a:
19181
293
              GETBYTE ();
19182
293
              switch (op[2] & 0x00)
19183
293
              {
19184
293
                case 0x00:
19185
293
                  goto op_semantics_147;
19186
0
                  break;
19187
293
              }
19188
0
            break;
19189
995
          case 0x4b:
19190
995
              GETBYTE ();
19191
995
              switch (op[2] & 0x00)
19192
995
              {
19193
995
                case 0x00:
19194
995
                  goto op_semantics_147;
19195
0
                  break;
19196
995
              }
19197
0
            break;
19198
1.60k
          case 0x4c:
19199
1.60k
              GETBYTE ();
19200
1.60k
              switch (op[2] & 0x00)
19201
1.60k
              {
19202
1.60k
                case 0x00:
19203
1.60k
                  goto op_semantics_147;
19204
0
                  break;
19205
1.60k
              }
19206
0
            break;
19207
590
          case 0x4d:
19208
590
              GETBYTE ();
19209
590
              switch (op[2] & 0x00)
19210
590
              {
19211
590
                case 0x00:
19212
590
                  goto op_semantics_147;
19213
0
                  break;
19214
590
              }
19215
0
            break;
19216
891
          case 0x4e:
19217
891
              GETBYTE ();
19218
891
              switch (op[2] & 0x00)
19219
891
              {
19220
891
                case 0x00:
19221
891
                  goto op_semantics_147;
19222
0
                  break;
19223
891
              }
19224
0
            break;
19225
311
          case 0x4f:
19226
311
              GETBYTE ();
19227
311
              switch (op[2] & 0x00)
19228
311
              {
19229
311
                case 0x00:
19230
311
                  goto op_semantics_147;
19231
0
                  break;
19232
311
              }
19233
0
            break;
19234
383
          case 0x50:
19235
383
              GETBYTE ();
19236
383
              switch (op[2] & 0x00)
19237
383
              {
19238
381
                case 0x00:
19239
6.32k
                  op_semantics_148:
19240
6.32k
                    {
19241
                      /** 1111 1111 0101 rdst srca srcb or  %2, %1, %0 */
19242
6.32k
#line 465 "rx-decode.opc"
19243
6.32k
                      int rdst AU = op[1] & 0x0f;
19244
6.32k
#line 465 "rx-decode.opc"
19245
6.32k
                      int srca AU = (op[2] >> 4) & 0x0f;
19246
6.32k
#line 465 "rx-decode.opc"
19247
6.32k
                      int srcb AU = op[2] & 0x0f;
19248
6.32k
                      if (trace)
19249
0
                        {
19250
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19251
0
                                 "/** 1111 1111 0101 rdst srca srcb or  %2, %1, %0 */",
19252
0
                                 op[0], op[1], op[2]);
19253
0
                          printf ("  rdst = 0x%x,", rdst);
19254
0
                          printf ("  srca = 0x%x,", srca);
19255
0
                          printf ("  srcb = 0x%x\n", srcb);
19256
0
                        }
19257
6.32k
                      SYNTAX("or  %2, %1, %0");
19258
6.32k
#line 465 "rx-decode.opc"
19259
6.32k
                      ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19260
19261
                    /*----------------------------------------------------------------------*/
19262
                    /* XOR                  */
19263
19264
6.32k
                    }
19265
6.32k
                  break;
19266
383
              }
19267
6.32k
            break;
19268
6.32k
          case 0x51:
19269
196
              GETBYTE ();
19270
196
              switch (op[2] & 0x00)
19271
196
              {
19272
196
                case 0x00:
19273
196
                  goto op_semantics_148;
19274
0
                  break;
19275
196
              }
19276
0
            break;
19277
490
          case 0x52:
19278
490
              GETBYTE ();
19279
490
              switch (op[2] & 0x00)
19280
490
              {
19281
490
                case 0x00:
19282
490
                  goto op_semantics_148;
19283
0
                  break;
19284
490
              }
19285
0
            break;
19286
573
          case 0x53:
19287
573
              GETBYTE ();
19288
573
              switch (op[2] & 0x00)
19289
573
              {
19290
573
                case 0x00:
19291
573
                  goto op_semantics_148;
19292
0
                  break;
19293
573
              }
19294
0
            break;
19295
461
          case 0x54:
19296
461
              GETBYTE ();
19297
461
              switch (op[2] & 0x00)
19298
461
              {
19299
461
                case 0x00:
19300
461
                  goto op_semantics_148;
19301
0
                  break;
19302
461
              }
19303
0
            break;
19304
326
          case 0x55:
19305
326
              GETBYTE ();
19306
326
              switch (op[2] & 0x00)
19307
326
              {
19308
326
                case 0x00:
19309
326
                  goto op_semantics_148;
19310
0
                  break;
19311
326
              }
19312
0
            break;
19313
588
          case 0x56:
19314
588
              GETBYTE ();
19315
588
              switch (op[2] & 0x00)
19316
588
              {
19317
588
                case 0x00:
19318
588
                  goto op_semantics_148;
19319
0
                  break;
19320
588
              }
19321
0
            break;
19322
327
          case 0x57:
19323
327
              GETBYTE ();
19324
327
              switch (op[2] & 0x00)
19325
327
              {
19326
327
                case 0x00:
19327
327
                  goto op_semantics_148;
19328
0
                  break;
19329
327
              }
19330
0
            break;
19331
279
          case 0x58:
19332
279
              GETBYTE ();
19333
279
              switch (op[2] & 0x00)
19334
279
              {
19335
279
                case 0x00:
19336
279
                  goto op_semantics_148;
19337
0
                  break;
19338
279
              }
19339
0
            break;
19340
514
          case 0x59:
19341
514
              GETBYTE ();
19342
514
              switch (op[2] & 0x00)
19343
514
              {
19344
514
                case 0x00:
19345
514
                  goto op_semantics_148;
19346
0
                  break;
19347
514
              }
19348
0
            break;
19349
262
          case 0x5a:
19350
262
              GETBYTE ();
19351
262
              switch (op[2] & 0x00)
19352
262
              {
19353
262
                case 0x00:
19354
262
                  goto op_semantics_148;
19355
0
                  break;
19356
262
              }
19357
0
            break;
19358
281
          case 0x5b:
19359
281
              GETBYTE ();
19360
281
              switch (op[2] & 0x00)
19361
281
              {
19362
281
                case 0x00:
19363
281
                  goto op_semantics_148;
19364
0
                  break;
19365
281
              }
19366
0
            break;
19367
255
          case 0x5c:
19368
255
              GETBYTE ();
19369
255
              switch (op[2] & 0x00)
19370
255
              {
19371
255
                case 0x00:
19372
255
                  goto op_semantics_148;
19373
0
                  break;
19374
255
              }
19375
0
            break;
19376
435
          case 0x5d:
19377
435
              GETBYTE ();
19378
435
              switch (op[2] & 0x00)
19379
435
              {
19380
435
                case 0x00:
19381
435
                  goto op_semantics_148;
19382
0
                  break;
19383
435
              }
19384
0
            break;
19385
531
          case 0x5e:
19386
531
              GETBYTE ();
19387
531
              switch (op[2] & 0x00)
19388
531
              {
19389
531
                case 0x00:
19390
531
                  goto op_semantics_148;
19391
0
                  break;
19392
531
              }
19393
0
            break;
19394
431
          case 0x5f:
19395
431
              GETBYTE ();
19396
431
              switch (op[2] & 0x00)
19397
431
              {
19398
430
                case 0x00:
19399
430
                  goto op_semantics_148;
19400
0
                  break;
19401
431
              }
19402
0
            break;
19403
2.01k
          case 0x60:
19404
2.01k
              GETBYTE ();
19405
2.01k
              switch (op[2] & 0x00)
19406
2.01k
              {
19407
2.01k
                case 0x00:
19408
11.6k
                  op_semantics_149:
19409
11.6k
                    {
19410
                      /** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */
19411
11.6k
#line 1146 "rx-decode.opc"
19412
11.6k
                      int rdst AU = op[1] & 0x0f;
19413
11.6k
#line 1146 "rx-decode.opc"
19414
11.6k
                      int srca AU = (op[2] >> 4) & 0x0f;
19415
11.6k
#line 1146 "rx-decode.opc"
19416
11.6k
                      int srcb AU = op[2] & 0x0f;
19417
11.6k
                      if (trace)
19418
0
                        {
19419
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19420
0
                                 "/** 1111 1111 0110 rdst srca srcb xor %2, %1, %0 */",
19421
0
                                 op[0], op[1], op[2]);
19422
0
                          printf ("  rdst = 0x%x,", rdst);
19423
0
                          printf ("  srca = 0x%x,", srca);
19424
0
                          printf ("  srcb = 0x%x\n", srcb);
19425
0
                        }
19426
11.6k
                      SYNTAX("xor %2, %1, %0");
19427
11.6k
#line 1146 "rx-decode.opc"
19428
11.6k
                      ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19429
19430
11.6k
                    }
19431
11.6k
                  break;
19432
2.01k
              }
19433
11.6k
            break;
19434
11.6k
          case 0x61:
19435
1.14k
              GETBYTE ();
19436
1.14k
              switch (op[2] & 0x00)
19437
1.14k
              {
19438
1.14k
                case 0x00:
19439
1.14k
                  goto op_semantics_149;
19440
0
                  break;
19441
1.14k
              }
19442
0
            break;
19443
1.26k
          case 0x62:
19444
1.26k
              GETBYTE ();
19445
1.26k
              switch (op[2] & 0x00)
19446
1.26k
              {
19447
1.26k
                case 0x00:
19448
1.26k
                  goto op_semantics_149;
19449
0
                  break;
19450
1.26k
              }
19451
0
            break;
19452
249
          case 0x63:
19453
249
              GETBYTE ();
19454
249
              switch (op[2] & 0x00)
19455
249
              {
19456
249
                case 0x00:
19457
249
                  goto op_semantics_149;
19458
0
                  break;
19459
249
              }
19460
0
            break;
19461
1.36k
          case 0x64:
19462
1.36k
              GETBYTE ();
19463
1.36k
              switch (op[2] & 0x00)
19464
1.36k
              {
19465
1.35k
                case 0x00:
19466
1.35k
                  goto op_semantics_149;
19467
0
                  break;
19468
1.36k
              }
19469
0
            break;
19470
395
          case 0x65:
19471
395
              GETBYTE ();
19472
395
              switch (op[2] & 0x00)
19473
395
              {
19474
395
                case 0x00:
19475
395
                  goto op_semantics_149;
19476
0
                  break;
19477
395
              }
19478
0
            break;
19479
529
          case 0x66:
19480
529
              GETBYTE ();
19481
529
              switch (op[2] & 0x00)
19482
529
              {
19483
529
                case 0x00:
19484
529
                  goto op_semantics_149;
19485
0
                  break;
19486
529
              }
19487
0
            break;
19488
195
          case 0x67:
19489
195
              GETBYTE ();
19490
195
              switch (op[2] & 0x00)
19491
195
              {
19492
195
                case 0x00:
19493
195
                  goto op_semantics_149;
19494
0
                  break;
19495
195
              }
19496
0
            break;
19497
754
          case 0x68:
19498
754
              GETBYTE ();
19499
754
              switch (op[2] & 0x00)
19500
754
              {
19501
734
                case 0x00:
19502
734
                  goto op_semantics_149;
19503
0
                  break;
19504
754
              }
19505
0
            break;
19506
347
          case 0x69:
19507
347
              GETBYTE ();
19508
347
              switch (op[2] & 0x00)
19509
347
              {
19510
347
                case 0x00:
19511
347
                  goto op_semantics_149;
19512
0
                  break;
19513
347
              }
19514
0
            break;
19515
482
          case 0x6a:
19516
482
              GETBYTE ();
19517
482
              switch (op[2] & 0x00)
19518
482
              {
19519
482
                case 0x00:
19520
482
                  goto op_semantics_149;
19521
0
                  break;
19522
482
              }
19523
0
            break;
19524
472
          case 0x6b:
19525
472
              GETBYTE ();
19526
472
              switch (op[2] & 0x00)
19527
472
              {
19528
472
                case 0x00:
19529
472
                  goto op_semantics_149;
19530
0
                  break;
19531
472
              }
19532
0
            break;
19533
757
          case 0x6c:
19534
757
              GETBYTE ();
19535
757
              switch (op[2] & 0x00)
19536
757
              {
19537
751
                case 0x00:
19538
751
                  goto op_semantics_149;
19539
0
                  break;
19540
757
              }
19541
0
            break;
19542
376
          case 0x6d:
19543
376
              GETBYTE ();
19544
376
              switch (op[2] & 0x00)
19545
376
              {
19546
376
                case 0x00:
19547
376
                  goto op_semantics_149;
19548
0
                  break;
19549
376
              }
19550
0
            break;
19551
514
          case 0x6e:
19552
514
              GETBYTE ();
19553
514
              switch (op[2] & 0x00)
19554
514
              {
19555
508
                case 0x00:
19556
508
                  goto op_semantics_149;
19557
0
                  break;
19558
514
              }
19559
0
            break;
19560
849
          case 0x6f:
19561
849
              GETBYTE ();
19562
849
              switch (op[2] & 0x00)
19563
849
              {
19564
849
                case 0x00:
19565
849
                  goto op_semantics_149;
19566
0
                  break;
19567
849
              }
19568
0
            break;
19569
2.82k
          case 0x80:
19570
2.82k
              GETBYTE ();
19571
2.82k
              switch (op[2] & 0x00)
19572
2.82k
              {
19573
2.82k
                case 0x00:
19574
11.1k
                  op_semantics_150:
19575
11.1k
                    {
19576
                      /** 1111 1111 1000 rdst srca srcb fsub  %2, %1, %0 */
19577
11.1k
#line 1125 "rx-decode.opc"
19578
11.1k
                      int rdst AU = op[1] & 0x0f;
19579
11.1k
#line 1125 "rx-decode.opc"
19580
11.1k
                      int srca AU = (op[2] >> 4) & 0x0f;
19581
11.1k
#line 1125 "rx-decode.opc"
19582
11.1k
                      int srcb AU = op[2] & 0x0f;
19583
11.1k
                      if (trace)
19584
0
                        {
19585
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19586
0
                                 "/** 1111 1111 1000 rdst srca srcb fsub  %2, %1, %0 */",
19587
0
                                 op[0], op[1], op[2]);
19588
0
                          printf ("  rdst = 0x%x,", rdst);
19589
0
                          printf ("  srca = 0x%x,", srca);
19590
0
                          printf ("  srcb = 0x%x\n", srcb);
19591
0
                        }
19592
11.1k
                      SYNTAX("fsub  %2, %1, %0");
19593
11.1k
#line 1125 "rx-decode.opc"
19594
11.1k
                      ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19595
19596
11.1k
                    }
19597
11.1k
                  break;
19598
2.82k
              }
19599
11.1k
            break;
19600
11.1k
          case 0x81:
19601
384
              GETBYTE ();
19602
384
              switch (op[2] & 0x00)
19603
384
              {
19604
384
                case 0x00:
19605
384
                  goto op_semantics_150;
19606
0
                  break;
19607
384
              }
19608
0
            break;
19609
208
          case 0x82:
19610
208
              GETBYTE ();
19611
208
              switch (op[2] & 0x00)
19612
208
              {
19613
208
                case 0x00:
19614
208
                  goto op_semantics_150;
19615
0
                  break;
19616
208
              }
19617
0
            break;
19618
855
          case 0x83:
19619
855
              GETBYTE ();
19620
855
              switch (op[2] & 0x00)
19621
855
              {
19622
855
                case 0x00:
19623
855
                  goto op_semantics_150;
19624
0
                  break;
19625
855
              }
19626
0
            break;
19627
250
          case 0x84:
19628
250
              GETBYTE ();
19629
250
              switch (op[2] & 0x00)
19630
250
              {
19631
250
                case 0x00:
19632
250
                  goto op_semantics_150;
19633
0
                  break;
19634
250
              }
19635
0
            break;
19636
524
          case 0x85:
19637
524
              GETBYTE ();
19638
524
              switch (op[2] & 0x00)
19639
524
              {
19640
524
                case 0x00:
19641
524
                  goto op_semantics_150;
19642
0
                  break;
19643
524
              }
19644
0
            break;
19645
139
          case 0x86:
19646
139
              GETBYTE ();
19647
139
              switch (op[2] & 0x00)
19648
139
              {
19649
139
                case 0x00:
19650
139
                  goto op_semantics_150;
19651
0
                  break;
19652
139
              }
19653
0
            break;
19654
454
          case 0x87:
19655
454
              GETBYTE ();
19656
454
              switch (op[2] & 0x00)
19657
454
              {
19658
454
                case 0x00:
19659
454
                  goto op_semantics_150;
19660
0
                  break;
19661
454
              }
19662
0
            break;
19663
528
          case 0x88:
19664
528
              GETBYTE ();
19665
528
              switch (op[2] & 0x00)
19666
528
              {
19667
528
                case 0x00:
19668
528
                  goto op_semantics_150;
19669
0
                  break;
19670
528
              }
19671
0
            break;
19672
733
          case 0x89:
19673
733
              GETBYTE ();
19674
733
              switch (op[2] & 0x00)
19675
733
              {
19676
733
                case 0x00:
19677
733
                  goto op_semantics_150;
19678
0
                  break;
19679
733
              }
19680
0
            break;
19681
701
          case 0x8a:
19682
701
              GETBYTE ();
19683
701
              switch (op[2] & 0x00)
19684
701
              {
19685
698
                case 0x00:
19686
698
                  goto op_semantics_150;
19687
0
                  break;
19688
701
              }
19689
0
            break;
19690
881
          case 0x8b:
19691
881
              GETBYTE ();
19692
881
              switch (op[2] & 0x00)
19693
881
              {
19694
880
                case 0x00:
19695
880
                  goto op_semantics_150;
19696
0
                  break;
19697
881
              }
19698
0
            break;
19699
203
          case 0x8c:
19700
203
              GETBYTE ();
19701
203
              switch (op[2] & 0x00)
19702
203
              {
19703
203
                case 0x00:
19704
203
                  goto op_semantics_150;
19705
0
                  break;
19706
203
              }
19707
0
            break;
19708
419
          case 0x8d:
19709
419
              GETBYTE ();
19710
419
              switch (op[2] & 0x00)
19711
419
              {
19712
419
                case 0x00:
19713
419
                  goto op_semantics_150;
19714
0
                  break;
19715
419
              }
19716
0
            break;
19717
1.45k
          case 0x8e:
19718
1.45k
              GETBYTE ();
19719
1.45k
              switch (op[2] & 0x00)
19720
1.45k
              {
19721
1.45k
                case 0x00:
19722
1.45k
                  goto op_semantics_150;
19723
0
                  break;
19724
1.45k
              }
19725
0
            break;
19726
623
          case 0x8f:
19727
623
              GETBYTE ();
19728
623
              switch (op[2] & 0x00)
19729
623
              {
19730
623
                case 0x00:
19731
623
                  goto op_semantics_150;
19732
0
                  break;
19733
623
              }
19734
0
            break;
19735
578
          case 0xa0:
19736
578
              GETBYTE ();
19737
578
              switch (op[2] & 0x00)
19738
578
              {
19739
578
                case 0x00:
19740
5.72k
                  op_semantics_151:
19741
5.72k
                    {
19742
                      /** 1111 1111 1010 rdst srca srcb fadd  %2, %1, %0 */
19743
5.72k
#line 1122 "rx-decode.opc"
19744
5.72k
                      int rdst AU = op[1] & 0x0f;
19745
5.72k
#line 1122 "rx-decode.opc"
19746
5.72k
                      int srca AU = (op[2] >> 4) & 0x0f;
19747
5.72k
#line 1122 "rx-decode.opc"
19748
5.72k
                      int srcb AU = op[2] & 0x0f;
19749
5.72k
                      if (trace)
19750
0
                        {
19751
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19752
0
                                 "/** 1111 1111 1010 rdst srca srcb fadd  %2, %1, %0 */",
19753
0
                                 op[0], op[1], op[2]);
19754
0
                          printf ("  rdst = 0x%x,", rdst);
19755
0
                          printf ("  srca = 0x%x,", srca);
19756
0
                          printf ("  srcb = 0x%x\n", srcb);
19757
0
                        }
19758
5.72k
                      SYNTAX("fadd  %2, %1, %0");
19759
5.72k
#line 1122 "rx-decode.opc"
19760
5.72k
                      ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19761
19762
5.72k
                    }
19763
5.72k
                  break;
19764
578
              }
19765
5.72k
            break;
19766
5.72k
          case 0xa1:
19767
485
              GETBYTE ();
19768
485
              switch (op[2] & 0x00)
19769
485
              {
19770
485
                case 0x00:
19771
485
                  goto op_semantics_151;
19772
0
                  break;
19773
485
              }
19774
0
            break;
19775
117
          case 0xa2:
19776
117
              GETBYTE ();
19777
117
              switch (op[2] & 0x00)
19778
117
              {
19779
117
                case 0x00:
19780
117
                  goto op_semantics_151;
19781
0
                  break;
19782
117
              }
19783
0
            break;
19784
574
          case 0xa3:
19785
574
              GETBYTE ();
19786
574
              switch (op[2] & 0x00)
19787
574
              {
19788
574
                case 0x00:
19789
574
                  goto op_semantics_151;
19790
0
                  break;
19791
574
              }
19792
0
            break;
19793
237
          case 0xa4:
19794
237
              GETBYTE ();
19795
237
              switch (op[2] & 0x00)
19796
237
              {
19797
237
                case 0x00:
19798
237
                  goto op_semantics_151;
19799
0
                  break;
19800
237
              }
19801
0
            break;
19802
406
          case 0xa5:
19803
406
              GETBYTE ();
19804
406
              switch (op[2] & 0x00)
19805
406
              {
19806
406
                case 0x00:
19807
406
                  goto op_semantics_151;
19808
0
                  break;
19809
406
              }
19810
0
            break;
19811
212
          case 0xa6:
19812
212
              GETBYTE ();
19813
212
              switch (op[2] & 0x00)
19814
212
              {
19815
212
                case 0x00:
19816
212
                  goto op_semantics_151;
19817
0
                  break;
19818
212
              }
19819
0
            break;
19820
151
          case 0xa7:
19821
151
              GETBYTE ();
19822
151
              switch (op[2] & 0x00)
19823
151
              {
19824
151
                case 0x00:
19825
151
                  goto op_semantics_151;
19826
0
                  break;
19827
151
              }
19828
0
            break;
19829
490
          case 0xa8:
19830
490
              GETBYTE ();
19831
490
              switch (op[2] & 0x00)
19832
490
              {
19833
490
                case 0x00:
19834
490
                  goto op_semantics_151;
19835
0
                  break;
19836
490
              }
19837
0
            break;
19838
173
          case 0xa9:
19839
173
              GETBYTE ();
19840
173
              switch (op[2] & 0x00)
19841
173
              {
19842
173
                case 0x00:
19843
173
                  goto op_semantics_151;
19844
0
                  break;
19845
173
              }
19846
0
            break;
19847
129
          case 0xaa:
19848
129
              GETBYTE ();
19849
129
              switch (op[2] & 0x00)
19850
129
              {
19851
129
                case 0x00:
19852
129
                  goto op_semantics_151;
19853
0
                  break;
19854
129
              }
19855
0
            break;
19856
385
          case 0xab:
19857
385
              GETBYTE ();
19858
385
              switch (op[2] & 0x00)
19859
385
              {
19860
385
                case 0x00:
19861
385
                  goto op_semantics_151;
19862
0
                  break;
19863
385
              }
19864
0
            break;
19865
831
          case 0xac:
19866
831
              GETBYTE ();
19867
831
              switch (op[2] & 0x00)
19868
831
              {
19869
831
                case 0x00:
19870
831
                  goto op_semantics_151;
19871
0
                  break;
19872
831
              }
19873
0
            break;
19874
153
          case 0xad:
19875
153
              GETBYTE ();
19876
153
              switch (op[2] & 0x00)
19877
153
              {
19878
153
                case 0x00:
19879
153
                  goto op_semantics_151;
19880
0
                  break;
19881
153
              }
19882
0
            break;
19883
234
          case 0xae:
19884
234
              GETBYTE ();
19885
234
              switch (op[2] & 0x00)
19886
234
              {
19887
234
                case 0x00:
19888
234
                  goto op_semantics_151;
19889
0
                  break;
19890
234
              }
19891
0
            break;
19892
571
          case 0xaf:
19893
571
              GETBYTE ();
19894
571
              switch (op[2] & 0x00)
19895
571
              {
19896
571
                case 0x00:
19897
571
                  goto op_semantics_151;
19898
0
                  break;
19899
571
              }
19900
0
            break;
19901
547
          case 0xb0:
19902
547
              GETBYTE ();
19903
547
              switch (op[2] & 0x00)
19904
547
              {
19905
547
                case 0x00:
19906
8.37k
                  op_semantics_152:
19907
8.37k
                    {
19908
                      /** 1111 1111 1011 rdst srca srcb fmul  %2, %1, %0 */
19909
8.37k
#line 1128 "rx-decode.opc"
19910
8.37k
                      int rdst AU = op[1] & 0x0f;
19911
8.37k
#line 1128 "rx-decode.opc"
19912
8.37k
                      int srca AU = (op[2] >> 4) & 0x0f;
19913
8.37k
#line 1128 "rx-decode.opc"
19914
8.37k
                      int srcb AU = op[2] & 0x0f;
19915
8.37k
                      if (trace)
19916
0
                        {
19917
0
                          printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19918
0
                                 "/** 1111 1111 1011 rdst srca srcb fmul  %2, %1, %0 */",
19919
0
                                 op[0], op[1], op[2]);
19920
0
                          printf ("  rdst = 0x%x,", rdst);
19921
0
                          printf ("  srca = 0x%x,", srca);
19922
0
                          printf ("  srcb = 0x%x\n", srcb);
19923
0
                        }
19924
8.37k
                      SYNTAX("fmul  %2, %1, %0");
19925
8.37k
#line 1128 "rx-decode.opc"
19926
8.37k
                      ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19927
19928
8.37k
                    }
19929
8.37k
                  break;
19930
547
              }
19931
8.37k
            break;
19932
8.37k
          case 0xb1:
19933
229
              GETBYTE ();
19934
229
              switch (op[2] & 0x00)
19935
229
              {
19936
229
                case 0x00:
19937
229
                  goto op_semantics_152;
19938
0
                  break;
19939
229
              }
19940
0
            break;
19941
674
          case 0xb2:
19942
674
              GETBYTE ();
19943
674
              switch (op[2] & 0x00)
19944
674
              {
19945
674
                case 0x00:
19946
674
                  goto op_semantics_152;
19947
0
                  break;
19948
674
              }
19949
0
            break;
19950
456
          case 0xb3:
19951
456
              GETBYTE ();
19952
456
              switch (op[2] & 0x00)
19953
456
              {
19954
436
                case 0x00:
19955
436
                  goto op_semantics_152;
19956
0
                  break;
19957
456
              }
19958
0
            break;
19959
1.62k
          case 0xb4:
19960
1.62k
              GETBYTE ();
19961
1.62k
              switch (op[2] & 0x00)
19962
1.62k
              {
19963
1.62k
                case 0x00:
19964
1.62k
                  goto op_semantics_152;
19965
0
                  break;
19966
1.62k
              }
19967
0
            break;
19968
540
          case 0xb5:
19969
540
              GETBYTE ();
19970
540
              switch (op[2] & 0x00)
19971
540
              {
19972
540
                case 0x00:
19973
540
                  goto op_semantics_152;
19974
0
                  break;
19975
540
              }
19976
0
            break;
19977
315
          case 0xb6:
19978
315
              GETBYTE ();
19979
315
              switch (op[2] & 0x00)
19980
315
              {
19981
315
                case 0x00:
19982
315
                  goto op_semantics_152;
19983
0
                  break;
19984
315
              }
19985
0
            break;
19986
302
          case 0xb7:
19987
302
              GETBYTE ();
19988
302
              switch (op[2] & 0x00)
19989
302
              {
19990
302
                case 0x00:
19991
302
                  goto op_semantics_152;
19992
0
                  break;
19993
302
              }
19994
0
            break;
19995
334
          case 0xb8:
19996
334
              GETBYTE ();
19997
334
              switch (op[2] & 0x00)
19998
334
              {
19999
334
                case 0x00:
20000
334
                  goto op_semantics_152;
20001
0
                  break;
20002
334
              }
20003
0
            break;
20004
403
          case 0xb9:
20005
403
              GETBYTE ();
20006
403
              switch (op[2] & 0x00)
20007
403
              {
20008
403
                case 0x00:
20009
403
                  goto op_semantics_152;
20010
0
                  break;
20011
403
              }
20012
0
            break;
20013
893
          case 0xba:
20014
893
              GETBYTE ();
20015
893
              switch (op[2] & 0x00)
20016
893
              {
20017
893
                case 0x00:
20018
893
                  goto op_semantics_152;
20019
0
                  break;
20020
893
              }
20021
0
            break;
20022
206
          case 0xbb:
20023
206
              GETBYTE ();
20024
206
              switch (op[2] & 0x00)
20025
206
              {
20026
206
                case 0x00:
20027
206
                  goto op_semantics_152;
20028
0
                  break;
20029
206
              }
20030
0
            break;
20031
764
          case 0xbc:
20032
764
              GETBYTE ();
20033
764
              switch (op[2] & 0x00)
20034
764
              {
20035
764
                case 0x00:
20036
764
                  goto op_semantics_152;
20037
0
                  break;
20038
764
              }
20039
0
            break;
20040
70
          case 0xbd:
20041
70
              GETBYTE ();
20042
70
              switch (op[2] & 0x00)
20043
70
              {
20044
70
                case 0x00:
20045
70
                  goto op_semantics_152;
20046
0
                  break;
20047
70
              }
20048
0
            break;
20049
247
          case 0xbe:
20050
247
              GETBYTE ();
20051
247
              switch (op[2] & 0x00)
20052
247
              {
20053
247
                case 0x00:
20054
247
                  goto op_semantics_152;
20055
0
                  break;
20056
247
              }
20057
0
            break;
20058
787
          case 0xbf:
20059
787
              GETBYTE ();
20060
787
              switch (op[2] & 0x00)
20061
787
              {
20062
787
                case 0x00:
20063
787
                  goto op_semantics_152;
20064
0
                  break;
20065
787
              }
20066
0
            break;
20067
644k
          default: UNSUPPORTED(); break;
20068
824k
        }
20069
824k
      break;
20070
824k
    default: UNSUPPORTED(); break;
20071
15.3M
  }
20072
15.3M
#line 1280 "rx-decode.opc"
20073
20074
15.3M
  return rx->n_bytes;
20075
15.3M
}