opcodes/rx-decode.c

   1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
   2 #line 1 "rx-decode.opc"
   3 /* -*- c -*- */
   4 /* Copyright (C) 2012-2019 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 #define ID(x) rx->id = RXO_##x
  90 #define OP(n,t,r,a) (rx->op[n].type = t, \
  91                      rx->op[n].reg = r,      \
  92                      rx->op[n].addend = a )
  93 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \
  94                         rx->op[n].size = s )
  95
  96 /* This is for the BWL and BW bitfields.  */
  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 #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 #define DC(c)       OP (0, RX_Operand_Immediate, 0, c)
 120 #define DR(r)       OP (0, RX_Operand_Register,  r, 0)
 121 #define DI(r,a)     OP (0, RX_Operand_Indirect,  r, a)
 122 #define DIs(r,a,s)  OP (0, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 123 #define DD(t,r,s)   rx_disp (0, t, r, bwl[s], ld);
 124 #define DF(r)       OP (0, RX_Operand_Flag,  flagmap[r], 0)
 125 #define DCR(r)      OP (0, RX_Operand_DoubleCReg, r, 0)
 126 #define DDR(r)      OP (0, RX_Operand_DoubleReg,  r, 0)
 127 #define DDRH(r)     OP (0, RX_Operand_DoubleRegH,  r, 0)
 128 #define DDRL(r)     OP (0, RX_Operand_DoubleRegL,  r, 0)
 129 #define DCND(r)     OP (0, RX_Operand_DoubleCond, r, 0)
 130
 131 #define SC(i)       OP (1, RX_Operand_Immediate, 0, i)
 132 #define SR(r)       OP (1, RX_Operand_Register,  r, 0)
 133 #define SRR(r)      OP (1, RX_Operand_TwoReg,  r, 0)
 134 #define SI(r,a)     OP (1, RX_Operand_Indirect,  r, a)
 135 #define SIs(r,a,s)  OP (1, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 136 #define SD(t,r,s)   rx_disp (1, t, r, bwl[s], ld);
 137 #define SP(t,r)     rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1);
 138 #define SPm(t,r,m)  rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m];
 139 #define Scc(cc)     OP (1, RX_Operand_Condition,  cc, 0)
 140 #define SCR(r)      OP (1, RX_Operand_DoubleCReg, r, 0)
 141 #define SDR(r)      OP (1, RX_Operand_DoubleReg,  r, 0)
 142 #define SDRH(r)      OP (1, RX_Operand_DoubleRegH,  r, 0)
 143 #define SDRL(r)      OP (1, RX_Operand_DoubleRegL,  r, 0)
 144
 145 #define S2C(i)      OP (2, RX_Operand_Immediate, 0, i)
 146 #define S2R(r)      OP (2, RX_Operand_Register,  r, 0)
 147 #define S2I(r,a)    OP (2, RX_Operand_Indirect,  r, a)
 148 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect,  r, (a) * GET_SCALE (s))
 149 #define S2D(t,r,s)  rx_disp (2, t, r, bwl[s], ld);
 150 #define S2P(t,r)    rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2);
 151 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m];
 152 #define S2cc(cc)    OP (2, RX_Operand_Condition,  cc, 0)
 153 #define S2DR(r)     OP (2, RX_Operand_DoubleReg,  r, 0)
 154 #define S2CR(r)     OP (2, RX_Operand_DoubleCReg, r, 0)
 155
 156 #define SDD(t,r,s)  rx_disp (1, t, r, bwl, ld);
 157
 158 #define BWL(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz]
 159 #define sBWL(sz)    rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz]
 160 #define uBW(sz)     rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubw[sz]
 161 #define P(t, n)     rx->op[n].size = (t!=3) ? RX_UByte : RX_Long;
 162 #define DL(sz)      rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = _ld[sz]
 163
 164 #define F(f) store_flags(rx, f)
 165
 166 #define AU ATTRIBUTE_UNUSED
 167 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr))
 168
 169 #define SYNTAX(x) rx->syntax = x
 170
 171 #define UNSUPPORTED() \
 172   rx->syntax = "*unknown*"
 173
 174 #define IMM(sf)   immediate (sf, 0, ld)
 175 #define IMMex(sf) immediate (sf, 1, ld)
 176
 177 static int
 178 immediate (int sfield, int ex, LocalData * ld)
 179 {
 180   unsigned long i = 0, j;
 181
 182   switch (sfield)
 183     {
 184 #define B ((unsigned long) GETBYTE())
 185     case 0:
 186 #if RX_OPCODE_BIG_ENDIAN
 187       i  = B;
 188       if (ex && (i & 0x80))
 189         i -= 0x100;
 190       i <<= 24;
 191       i |= B << 16;
 192       i |= B << 8;
 193       i |= B;
 194 #else
 195       i = B;
 196       i |= B << 8;
 197       i |= B << 16;
 198       j = B;
 199       if (ex && (j & 0x80))
 200         j -= 0x100;
 201       i |= j << 24;
 202 #endif
 203       break;
 204     case 3:
 205 #if RX_OPCODE_BIG_ENDIAN
 206       i  = B << 16;
 207       i |= B << 8;
 208       i |= B;
 209 #else
 210       i  = B;
 211       i |= B << 8;
 212       i |= B << 16;
 213 #endif
 214       if (ex && (i & 0x800000))
 215         i -= 0x1000000;
 216       break;
 217     case 2:
 218 #if RX_OPCODE_BIG_ENDIAN
 219       i |= B << 8;
 220       i |= B;
 221 #else
 222       i |= B;
 223       i |= B << 8;
 224 #endif
 225       if (ex && (i & 0x8000))
 226         i -= 0x10000;
 227       break;
 228     case 1:
 229       i |= B;
 230       if (ex && (i & 0x80))
 231         i -= 0x100;
 232       break;
 233     default:
 234       abort();
 235     }
 236   return i;
 237 }
 238
 239 static void
 240 rx_disp (int n, int type, int reg, unsigned int size, LocalData * ld)
 241 {
 242   int disp;
 243
 244   ld->rx->op[n].reg = reg;
 245   switch (type)
 246     {
 247     case 3:
 248       ld->rx->op[n].type = RX_Operand_Register;
 249       break;
 250     case 0:
 251       ld->rx->op[n].type = RX_Operand_Zero_Indirect;
 252       ld->rx->op[n].addend = 0;
 253       break;
 254     case 1:
 255       ld->rx->op[n].type = RX_Operand_Indirect;
 256       disp = GETBYTE ();
 257       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 258       break;
 259     case 2:
 260       ld->rx->op[n].type = RX_Operand_Indirect;
 261       disp = GETBYTE ();
 262 #if RX_OPCODE_BIG_ENDIAN
 263       disp = disp * 256 + GETBYTE ();
 264 #else
 265       disp = disp + GETBYTE () * 256;
 266 #endif
 267       ld->rx->op[n].addend = disp * GET_PSCALE (size);
 268       break;
 269     default:
 270       abort ();
 271     }
 272 }
 273
 274 #define xO 8
 275 #define xS 4
 276 #define xZ 2
 277 #define xC 1
 278
 279 #define F_____
 280 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC;
 281 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ;
 282 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC;
 283 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC;
 284 #define F_O___ rx->flags_0 = rx->flags_s = xO;
 285 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS;
 286 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ;
 287 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC;
 288
 289 int
 290 rx_decode_opcode (unsigned long pc AU,
 291                   RX_Opcode_Decoded * rx,
 292                   int (* getbyte)(void *),
 293                   void * ptr)
 294 {
 295   LocalData lds, * ld = &lds;
 296   unsigned char op[20] = {0};
 297
 298   lds.rx = rx;
 299   lds.getbyte = getbyte;
 300   lds.ptr = ptr;
 301   lds.op = op;
 302
 303   memset (rx, 0, sizeof (*rx));
 304   BWL(LSIZE);
 305
 306
 307 /*----------------------------------------------------------------------*/
 308 /* MOV                                                                  */
 309
 310   GETBYTE ();
 311   switch (op[0] & 0xff)
 312   {
 313     case 0x00:
 314         {
 315           /** 0000 0000                 brk */
 316           if (trace)
 317             {
 318               printf ("\033[33m%s\033[0m  %02x\n",
 319                      "/** 0000 0000                     brk */",
 320                      op[0]);
 321             }
 322           SYNTAX("brk");
 323 #line 1050 "rx-decode.opc"
 324           ID(brk);
 325
 326         }
 327       break;
 328     case 0x01:
 329         {
 330           /** 0000 0001                 dbt */
 331           if (trace)
 332             {
 333               printf ("\033[33m%s\033[0m  %02x\n",
 334                      "/** 0000 0001                     dbt */",
 335                      op[0]);
 336             }
 337           SYNTAX("dbt");
 338 #line 1053 "rx-decode.opc"
 339           ID(dbt);
 340
 341         }
 342       break;
 343     case 0x02:
 344         {
 345           /** 0000 0010                 rts */
 346           if (trace)
 347             {
 348               printf ("\033[33m%s\033[0m  %02x\n",
 349                      "/** 0000 0010                     rts */",
 350                      op[0]);
 351             }
 352           SYNTAX("rts");
 353 #line 831 "rx-decode.opc"
 354           ID(rts);
 355
 356         /*----------------------------------------------------------------------*/
 357         /* NOP                                                          */
 358
 359         }
 360       break;
 361     case 0x03:
 362         {
 363           /** 0000 0011                 nop */
 364           if (trace)
 365             {
 366               printf ("\033[33m%s\033[0m  %02x\n",
 367                      "/** 0000 0011                     nop */",
 368                      op[0]);
 369             }
 370           SYNTAX("nop");
 371 #line 837 "rx-decode.opc"
 372           ID(nop);
 373
 374         /*----------------------------------------------------------------------*/
 375         /* STRING FUNCTIONS                                                     */
 376
 377         }
 378       break;
 379     case 0x04:
 380         {
 381           /** 0000 0100                 bra.a   %a0 */
 382           if (trace)
 383             {
 384               printf ("\033[33m%s\033[0m  %02x\n",
 385                      "/** 0000 0100                     bra.a   %a0 */",
 386                      op[0]);
 387             }
 388           SYNTAX("bra.a %a0");
 389 #line 809 "rx-decode.opc"
 390           ID(branch); DC(pc + IMMex(3));
 391
 392         }
 393       break;
 394     case 0x05:
 395         {
 396           /** 0000 0101                 bsr.a   %a0 */
 397           if (trace)
 398             {
 399               printf ("\033[33m%s\033[0m  %02x\n",
 400                      "/** 0000 0101                     bsr.a   %a0 */",
 401                      op[0]);
 402             }
 403           SYNTAX("bsr.a %a0");
 404 #line 825 "rx-decode.opc"
 405           ID(jsr); DC(pc + IMMex(3));
 406
 407         }
 408       break;
 409     case 0x06:
 410         GETBYTE ();
 411         switch (op[1] & 0xff)
 412         {
 413           case 0x00:
 414               GETBYTE ();
 415               switch (op[2] & 0x00)
 416               {
 417                 case 0x00:
 418                   op_semantics_1:
 419                     {
 420                       /** 0000 0110 mx00 00ss rsrc rdst                 sub     %2%S2, %1 */
 421 #line 567 "rx-decode.opc"
 422                       int mx AU = (op[1] >> 6) & 0x03;
 423 #line 567 "rx-decode.opc"
 424                       int ss AU = op[1] & 0x03;
 425 #line 567 "rx-decode.opc"
 426                       int rsrc AU = (op[2] >> 4) & 0x0f;
 427 #line 567 "rx-decode.opc"
 428                       int rdst AU = op[2] & 0x0f;
 429                       if (trace)
 430                         {
 431                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 432                                  "/** 0000 0110 mx00 00ss rsrc rdst                     sub     %2%S2, %1 */",
 433                                  op[0], op[1], op[2]);
 434                           printf ("  mx = 0x%x,", mx);
 435                           printf ("  ss = 0x%x,", ss);
 436                           printf ("  rsrc = 0x%x,", rsrc);
 437                           printf ("  rdst = 0x%x\n", rdst);
 438                         }
 439                       SYNTAX("sub       %2%S2, %1");
 440 #line 567 "rx-decode.opc"
 441                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
 442
 443                     }
 444                   break;
 445               }
 446             break;
 447           case 0x01:
 448               GETBYTE ();
 449               switch (op[2] & 0x00)
 450               {
 451                 case 0x00:
 452                   goto op_semantics_1;
 453                   break;
 454               }
 455             break;
 456           case 0x02:
 457               GETBYTE ();
 458               switch (op[2] & 0x00)
 459               {
 460                 case 0x00:
 461                   goto op_semantics_1;
 462                   break;
 463               }
 464             break;
 465           case 0x03:
 466               GETBYTE ();
 467               switch (op[2] & 0x00)
 468               {
 469                 case 0x00:
 470                   goto op_semantics_1;
 471                   break;
 472               }
 473             break;
 474           case 0x04:
 475               GETBYTE ();
 476               switch (op[2] & 0x00)
 477               {
 478                 case 0x00:
 479                   op_semantics_2:
 480                     {
 481                       /** 0000 0110 mx00 01ss rsrc rdst         cmp     %2%S2, %1 */
 482 #line 555 "rx-decode.opc"
 483                       int mx AU = (op[1] >> 6) & 0x03;
 484 #line 555 "rx-decode.opc"
 485                       int ss AU = op[1] & 0x03;
 486 #line 555 "rx-decode.opc"
 487                       int rsrc AU = (op[2] >> 4) & 0x0f;
 488 #line 555 "rx-decode.opc"
 489                       int rdst AU = op[2] & 0x0f;
 490                       if (trace)
 491                         {
 492                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 493                                  "/** 0000 0110 mx00 01ss rsrc rdst             cmp     %2%S2, %1 */",
 494                                  op[0], op[1], op[2]);
 495                           printf ("  mx = 0x%x,", mx);
 496                           printf ("  ss = 0x%x,", ss);
 497                           printf ("  rsrc = 0x%x,", rsrc);
 498                           printf ("  rdst = 0x%x\n", rdst);
 499                         }
 500                       SYNTAX("cmp       %2%S2, %1");
 501 #line 555 "rx-decode.opc"
 502                       ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
 503
 504                     /*----------------------------------------------------------------------*/
 505                     /* SUB                                                                      */
 506
 507                     }
 508                   break;
 509               }
 510             break;
 511           case 0x05:
 512               GETBYTE ();
 513               switch (op[2] & 0x00)
 514               {
 515                 case 0x00:
 516                   goto op_semantics_2;
 517                   break;
 518               }
 519             break;
 520           case 0x06:
 521               GETBYTE ();
 522               switch (op[2] & 0x00)
 523               {
 524                 case 0x00:
 525                   goto op_semantics_2;
 526                   break;
 527               }
 528             break;
 529           case 0x07:
 530               GETBYTE ();
 531               switch (op[2] & 0x00)
 532               {
 533                 case 0x00:
 534                   goto op_semantics_2;
 535                   break;
 536               }
 537             break;
 538           case 0x08:
 539               GETBYTE ();
 540               switch (op[2] & 0x00)
 541               {
 542                 case 0x00:
 543                   op_semantics_3:
 544                     {
 545                       /** 0000 0110 mx00 10ss rsrc rdst add     %1%S1, %0 */
 546 #line 531 "rx-decode.opc"
 547                       int mx AU = (op[1] >> 6) & 0x03;
 548 #line 531 "rx-decode.opc"
 549                       int ss AU = op[1] & 0x03;
 550 #line 531 "rx-decode.opc"
 551                       int rsrc AU = (op[2] >> 4) & 0x0f;
 552 #line 531 "rx-decode.opc"
 553                       int rdst AU = op[2] & 0x0f;
 554                       if (trace)
 555                         {
 556                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 557                                  "/** 0000 0110 mx00 10ss rsrc rdst     add     %1%S1, %0 */",
 558                                  op[0], op[1], op[2]);
 559                           printf ("  mx = 0x%x,", mx);
 560                           printf ("  ss = 0x%x,", ss);
 561                           printf ("  rsrc = 0x%x,", rsrc);
 562                           printf ("  rdst = 0x%x\n", rdst);
 563                         }
 564                       SYNTAX("add       %1%S1, %0");
 565 #line 531 "rx-decode.opc"
 566                       ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
 567
 568                     }
 569                   break;
 570               }
 571             break;
 572           case 0x09:
 573               GETBYTE ();
 574               switch (op[2] & 0x00)
 575               {
 576                 case 0x00:
 577                   goto op_semantics_3;
 578                   break;
 579               }
 580             break;
 581           case 0x0a:
 582               GETBYTE ();
 583               switch (op[2] & 0x00)
 584               {
 585                 case 0x00:
 586                   goto op_semantics_3;
 587                   break;
 588               }
 589             break;
 590           case 0x0b:
 591               GETBYTE ();
 592               switch (op[2] & 0x00)
 593               {
 594                 case 0x00:
 595                   goto op_semantics_3;
 596                   break;
 597               }
 598             break;
 599           case 0x0c:
 600               GETBYTE ();
 601               switch (op[2] & 0x00)
 602               {
 603                 case 0x00:
 604                   op_semantics_4:
 605                     {
 606                       /** 0000 0110 mx00 11ss rsrc rdst mul     %1%S1, %0 */
 607 #line 674 "rx-decode.opc"
 608                       int mx AU = (op[1] >> 6) & 0x03;
 609 #line 674 "rx-decode.opc"
 610                       int ss AU = op[1] & 0x03;
 611 #line 674 "rx-decode.opc"
 612                       int rsrc AU = (op[2] >> 4) & 0x0f;
 613 #line 674 "rx-decode.opc"
 614                       int rdst AU = op[2] & 0x0f;
 615                       if (trace)
 616                         {
 617                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 618                                  "/** 0000 0110 mx00 11ss rsrc rdst     mul     %1%S1, %0 */",
 619                                  op[0], op[1], op[2]);
 620                           printf ("  mx = 0x%x,", mx);
 621                           printf ("  ss = 0x%x,", ss);
 622                           printf ("  rsrc = 0x%x,", rsrc);
 623                           printf ("  rdst = 0x%x\n", rdst);
 624                         }
 625                       SYNTAX("mul       %1%S1, %0");
 626 #line 674 "rx-decode.opc"
 627                       ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
 628
 629                     }
 630                   break;
 631               }
 632             break;
 633           case 0x0d:
 634               GETBYTE ();
 635               switch (op[2] & 0x00)
 636               {
 637                 case 0x00:
 638                   goto op_semantics_4;
 639                   break;
 640               }
 641             break;
 642           case 0x0e:
 643               GETBYTE ();
 644               switch (op[2] & 0x00)
 645               {
 646                 case 0x00:
 647                   goto op_semantics_4;
 648                   break;
 649               }
 650             break;
 651           case 0x0f:
 652               GETBYTE ();
 653               switch (op[2] & 0x00)
 654               {
 655                 case 0x00:
 656                   goto op_semantics_4;
 657                   break;
 658               }
 659             break;
 660           case 0x10:
 661               GETBYTE ();
 662               switch (op[2] & 0x00)
 663               {
 664                 case 0x00:
 665                   op_semantics_5:
 666                     {
 667                       /** 0000 0110 mx01 00ss rsrc rdst and     %1%S1, %0 */
 668 #line 444 "rx-decode.opc"
 669                       int mx AU = (op[1] >> 6) & 0x03;
 670 #line 444 "rx-decode.opc"
 671                       int ss AU = op[1] & 0x03;
 672 #line 444 "rx-decode.opc"
 673                       int rsrc AU = (op[2] >> 4) & 0x0f;
 674 #line 444 "rx-decode.opc"
 675                       int rdst AU = op[2] & 0x0f;
 676                       if (trace)
 677                         {
 678                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 679                                  "/** 0000 0110 mx01 00ss rsrc rdst     and     %1%S1, %0 */",
 680                                  op[0], op[1], op[2]);
 681                           printf ("  mx = 0x%x,", mx);
 682                           printf ("  ss = 0x%x,", ss);
 683                           printf ("  rsrc = 0x%x,", rsrc);
 684                           printf ("  rdst = 0x%x\n", rdst);
 685                         }
 686                       SYNTAX("and       %1%S1, %0");
 687 #line 444 "rx-decode.opc"
 688                       ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 689
 690                     }
 691                   break;
 692               }
 693             break;
 694           case 0x11:
 695               GETBYTE ();
 696               switch (op[2] & 0x00)
 697               {
 698                 case 0x00:
 699                   goto op_semantics_5;
 700                   break;
 701               }
 702             break;
 703           case 0x12:
 704               GETBYTE ();
 705               switch (op[2] & 0x00)
 706               {
 707                 case 0x00:
 708                   goto op_semantics_5;
 709                   break;
 710               }
 711             break;
 712           case 0x13:
 713               GETBYTE ();
 714               switch (op[2] & 0x00)
 715               {
 716                 case 0x00:
 717                   goto op_semantics_5;
 718                   break;
 719               }
 720             break;
 721           case 0x14:
 722               GETBYTE ();
 723               switch (op[2] & 0x00)
 724               {
 725                 case 0x00:
 726                   op_semantics_6:
 727                     {
 728                       /** 0000 0110 mx01 01ss rsrc rdst                 or      %1%S1, %0 */
 729 #line 462 "rx-decode.opc"
 730                       int mx AU = (op[1] >> 6) & 0x03;
 731 #line 462 "rx-decode.opc"
 732                       int ss AU = op[1] & 0x03;
 733 #line 462 "rx-decode.opc"
 734                       int rsrc AU = (op[2] >> 4) & 0x0f;
 735 #line 462 "rx-decode.opc"
 736                       int rdst AU = op[2] & 0x0f;
 737                       if (trace)
 738                         {
 739                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
 740                                  "/** 0000 0110 mx01 01ss rsrc rdst                     or      %1%S1, %0 */",
 741                                  op[0], op[1], op[2]);
 742                           printf ("  mx = 0x%x,", mx);
 743                           printf ("  ss = 0x%x,", ss);
 744                           printf ("  rsrc = 0x%x,", rsrc);
 745                           printf ("  rdst = 0x%x\n", rdst);
 746                         }
 747                       SYNTAX("or        %1%S1, %0");
 748 #line 462 "rx-decode.opc"
 749                       ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
 750
 751                     }
 752                   break;
 753               }
 754             break;
 755           case 0x15:
 756               GETBYTE ();
 757               switch (op[2] & 0x00)
 758               {
 759                 case 0x00:
 760                   goto op_semantics_6;
 761                   break;
 762               }
 763             break;
 764           case 0x16:
 765               GETBYTE ();
 766               switch (op[2] & 0x00)
 767               {
 768                 case 0x00:
 769                   goto op_semantics_6;
 770                   break;
 771               }
 772             break;
 773           case 0x17:
 774               GETBYTE ();
 775               switch (op[2] & 0x00)
 776               {
 777                 case 0x00:
 778                   goto op_semantics_6;
 779                   break;
 780               }
 781             break;
 782           case 0x20:
 783               GETBYTE ();
 784               switch (op[2] & 0xff)
 785               {
 786                 case 0x00:
 787                     GETBYTE ();
 788                     switch (op[3] & 0x00)
 789                     {
 790                       case 0x00:
 791                         op_semantics_7:
 792                           {
 793                             /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb     %1%S1, %0 */
 794 #line 580 "rx-decode.opc"
 795                             int mx AU = (op[1] >> 6) & 0x03;
 796 #line 580 "rx-decode.opc"
 797                             int sp AU = op[1] & 0x03;
 798 #line 580 "rx-decode.opc"
 799                             int rsrc AU = (op[3] >> 4) & 0x0f;
 800 #line 580 "rx-decode.opc"
 801                             int rdst AU = op[3] & 0x0f;
 802                             if (trace)
 803                               {
 804                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 805                                        "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst     sbb     %1%S1, %0 */",
 806                                        op[0], op[1], op[2], op[3]);
 807                                 printf ("  mx = 0x%x,", mx);
 808                                 printf ("  sp = 0x%x,", sp);
 809                                 printf ("  rsrc = 0x%x,", rsrc);
 810                                 printf ("  rdst = 0x%x\n", rdst);
 811                               }
 812                             SYNTAX("sbb %1%S1, %0");
 813 #line 580 "rx-decode.opc"
 814                             ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
 815
 816                           /*----------------------------------------------------------------------*/
 817                           /* ABS                                                                        */
 818
 819                           }
 820                         break;
 821                     }
 822                   break;
 823                 case 0x04:
 824                     GETBYTE ();
 825                     switch (op[3] & 0x00)
 826                     {
 827                       case 0x00:
 828                         op_semantics_8:
 829                           {
 830                             /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max     %1%S1, %0 */
 831 #line 619 "rx-decode.opc"
 832                             int mx AU = (op[1] >> 6) & 0x03;
 833 #line 619 "rx-decode.opc"
 834                             int ss AU = op[1] & 0x03;
 835 #line 619 "rx-decode.opc"
 836                             int rsrc AU = (op[3] >> 4) & 0x0f;
 837 #line 619 "rx-decode.opc"
 838                             int rdst AU = op[3] & 0x0f;
 839                             if (trace)
 840                               {
 841                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 842                                        "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst     max     %1%S1, %0 */",
 843                                        op[0], op[1], op[2], op[3]);
 844                                 printf ("  mx = 0x%x,", mx);
 845                                 printf ("  ss = 0x%x,", ss);
 846                                 printf ("  rsrc = 0x%x,", rsrc);
 847                                 printf ("  rdst = 0x%x\n", rdst);
 848                               }
 849                             SYNTAX("max %1%S1, %0");
 850 #line 619 "rx-decode.opc"
 851                             ID(max); SPm(ss, rsrc, mx); DR(rdst);
 852
 853                           /*----------------------------------------------------------------------*/
 854                           /* MIN                                                                        */
 855
 856                           }
 857                         break;
 858                     }
 859                   break;
 860                 case 0x05:
 861                     GETBYTE ();
 862                     switch (op[3] & 0x00)
 863                     {
 864                       case 0x00:
 865                         op_semantics_9:
 866                           {
 867                             /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min     %1%S1, %0 */
 868 #line 631 "rx-decode.opc"
 869                             int mx AU = (op[1] >> 6) & 0x03;
 870 #line 631 "rx-decode.opc"
 871                             int ss AU = op[1] & 0x03;
 872 #line 631 "rx-decode.opc"
 873                             int rsrc AU = (op[3] >> 4) & 0x0f;
 874 #line 631 "rx-decode.opc"
 875                             int rdst AU = op[3] & 0x0f;
 876                             if (trace)
 877                               {
 878                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 879                                        "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst     min     %1%S1, %0 */",
 880                                        op[0], op[1], op[2], op[3]);
 881                                 printf ("  mx = 0x%x,", mx);
 882                                 printf ("  ss = 0x%x,", ss);
 883                                 printf ("  rsrc = 0x%x,", rsrc);
 884                                 printf ("  rdst = 0x%x\n", rdst);
 885                               }
 886                             SYNTAX("min %1%S1, %0");
 887 #line 631 "rx-decode.opc"
 888                             ID(min); SPm(ss, rsrc, mx); DR(rdst);
 889
 890                           /*----------------------------------------------------------------------*/
 891                           /* MUL                                                                        */
 892
 893                           }
 894                         break;
 895                     }
 896                   break;
 897                 case 0x06:
 898                     GETBYTE ();
 899                     switch (op[3] & 0x00)
 900                     {
 901                       case 0x00:
 902                         op_semantics_10:
 903                           {
 904                             /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul    %1%S1, %0 */
 905 #line 689 "rx-decode.opc"
 906                             int mx AU = (op[1] >> 6) & 0x03;
 907 #line 689 "rx-decode.opc"
 908                             int ss AU = op[1] & 0x03;
 909 #line 689 "rx-decode.opc"
 910                             int rsrc AU = (op[3] >> 4) & 0x0f;
 911 #line 689 "rx-decode.opc"
 912                             int rdst AU = op[3] & 0x0f;
 913                             if (trace)
 914                               {
 915                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 916                                        "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst     emul    %1%S1, %0 */",
 917                                        op[0], op[1], op[2], op[3]);
 918                                 printf ("  mx = 0x%x,", mx);
 919                                 printf ("  ss = 0x%x,", ss);
 920                                 printf ("  rsrc = 0x%x,", rsrc);
 921                                 printf ("  rdst = 0x%x\n", rdst);
 922                               }
 923                             SYNTAX("emul        %1%S1, %0");
 924 #line 689 "rx-decode.opc"
 925                             ID(emul); SPm(ss, rsrc, mx); DR(rdst);
 926
 927                           /*----------------------------------------------------------------------*/
 928                           /* EMULU                                                                      */
 929
 930                           }
 931                         break;
 932                     }
 933                   break;
 934                 case 0x07:
 935                     GETBYTE ();
 936                     switch (op[3] & 0x00)
 937                     {
 938                       case 0x00:
 939                         op_semantics_11:
 940                           {
 941                             /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu   %1%S1, %0 */
 942 #line 701 "rx-decode.opc"
 943                             int mx AU = (op[1] >> 6) & 0x03;
 944 #line 701 "rx-decode.opc"
 945                             int ss AU = op[1] & 0x03;
 946 #line 701 "rx-decode.opc"
 947                             int rsrc AU = (op[3] >> 4) & 0x0f;
 948 #line 701 "rx-decode.opc"
 949                             int rdst AU = op[3] & 0x0f;
 950                             if (trace)
 951                               {
 952                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 953                                        "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst     emulu   %1%S1, %0 */",
 954                                        op[0], op[1], op[2], op[3]);
 955                                 printf ("  mx = 0x%x,", mx);
 956                                 printf ("  ss = 0x%x,", ss);
 957                                 printf ("  rsrc = 0x%x,", rsrc);
 958                                 printf ("  rdst = 0x%x\n", rdst);
 959                               }
 960                             SYNTAX("emulu       %1%S1, %0");
 961 #line 701 "rx-decode.opc"
 962                             ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
 963
 964                           /*----------------------------------------------------------------------*/
 965                           /* DIV                                                                        */
 966
 967                           }
 968                         break;
 969                     }
 970                   break;
 971                 case 0x08:
 972                     GETBYTE ();
 973                     switch (op[3] & 0x00)
 974                     {
 975                       case 0x00:
 976                         op_semantics_12:
 977                           {
 978                             /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div     %1%S1, %0 */
 979 #line 713 "rx-decode.opc"
 980                             int mx AU = (op[1] >> 6) & 0x03;
 981 #line 713 "rx-decode.opc"
 982                             int ss AU = op[1] & 0x03;
 983 #line 713 "rx-decode.opc"
 984                             int rsrc AU = (op[3] >> 4) & 0x0f;
 985 #line 713 "rx-decode.opc"
 986                             int rdst AU = op[3] & 0x0f;
 987                             if (trace)
 988                               {
 989                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
 990                                        "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst     div     %1%S1, %0 */",
 991                                        op[0], op[1], op[2], op[3]);
 992                                 printf ("  mx = 0x%x,", mx);
 993                                 printf ("  ss = 0x%x,", ss);
 994                                 printf ("  rsrc = 0x%x,", rsrc);
 995                                 printf ("  rdst = 0x%x\n", rdst);
 996                               }
 997                             SYNTAX("div %1%S1, %0");
 998 #line 713 "rx-decode.opc"
 999                             ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1000
1001                           /*----------------------------------------------------------------------*/
1002                           /* DIVU                                                                       */
1003
1004                           }
1005                         break;
1006                     }
1007                   break;
1008                 case 0x09:
1009                     GETBYTE ();
1010                     switch (op[3] & 0x00)
1011                     {
1012                       case 0x00:
1013                         op_semantics_13:
1014                           {
1015                             /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu    %1%S1, %0 */
1016 #line 725 "rx-decode.opc"
1017                             int mx AU = (op[1] >> 6) & 0x03;
1018 #line 725 "rx-decode.opc"
1019                             int ss AU = op[1] & 0x03;
1020 #line 725 "rx-decode.opc"
1021                             int rsrc AU = (op[3] >> 4) & 0x0f;
1022 #line 725 "rx-decode.opc"
1023                             int rdst AU = op[3] & 0x0f;
1024                             if (trace)
1025                               {
1026                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1027                                        "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst     divu    %1%S1, %0 */",
1028                                        op[0], op[1], op[2], op[3]);
1029                                 printf ("  mx = 0x%x,", mx);
1030                                 printf ("  ss = 0x%x,", ss);
1031                                 printf ("  rsrc = 0x%x,", rsrc);
1032                                 printf ("  rdst = 0x%x\n", rdst);
1033                               }
1034                             SYNTAX("divu        %1%S1, %0");
1035 #line 725 "rx-decode.opc"
1036                             ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
1037
1038                           /*----------------------------------------------------------------------*/
1039                           /* SHIFT                                                              */
1040
1041                           }
1042                         break;
1043                     }
1044                   break;
1045                 case 0x0c:
1046                     GETBYTE ();
1047                     switch (op[3] & 0x00)
1048                     {
1049                       case 0x00:
1050                         op_semantics_14:
1051                           {
1052                             /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst     %1%S1, %2 */
1053 #line 498 "rx-decode.opc"
1054                             int mx AU = (op[1] >> 6) & 0x03;
1055 #line 498 "rx-decode.opc"
1056                             int ss AU = op[1] & 0x03;
1057 #line 498 "rx-decode.opc"
1058                             int rsrc AU = (op[3] >> 4) & 0x0f;
1059 #line 498 "rx-decode.opc"
1060                             int rdst AU = op[3] & 0x0f;
1061                             if (trace)
1062                               {
1063                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1064                                        "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst     tst     %1%S1, %2 */",
1065                                        op[0], op[1], op[2], op[3]);
1066                                 printf ("  mx = 0x%x,", mx);
1067                                 printf ("  ss = 0x%x,", ss);
1068                                 printf ("  rsrc = 0x%x,", rsrc);
1069                                 printf ("  rdst = 0x%x\n", rdst);
1070                               }
1071                             SYNTAX("tst %1%S1, %2");
1072 #line 498 "rx-decode.opc"
1073                             ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1074
1075                           /*----------------------------------------------------------------------*/
1076                           /* NEG                                                                        */
1077
1078                           }
1079                         break;
1080                     }
1081                   break;
1082                 case 0x0d:
1083                     GETBYTE ();
1084                     switch (op[3] & 0x00)
1085                     {
1086                       case 0x00:
1087                         op_semantics_15:
1088                           {
1089                             /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor     %1%S1, %0 */
1090 #line 477 "rx-decode.opc"
1091                             int mx AU = (op[1] >> 6) & 0x03;
1092 #line 477 "rx-decode.opc"
1093                             int ss AU = op[1] & 0x03;
1094 #line 477 "rx-decode.opc"
1095                             int rsrc AU = (op[3] >> 4) & 0x0f;
1096 #line 477 "rx-decode.opc"
1097                             int rdst AU = op[3] & 0x0f;
1098                             if (trace)
1099                               {
1100                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1101                                        "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst     xor     %1%S1, %0 */",
1102                                        op[0], op[1], op[2], op[3]);
1103                                 printf ("  mx = 0x%x,", mx);
1104                                 printf ("  ss = 0x%x,", ss);
1105                                 printf ("  rsrc = 0x%x,", rsrc);
1106                                 printf ("  rdst = 0x%x\n", rdst);
1107                               }
1108                             SYNTAX("xor %1%S1, %0");
1109 #line 477 "rx-decode.opc"
1110                             ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1111
1112                           /*----------------------------------------------------------------------*/
1113                           /* NOT                                                                        */
1114
1115                           }
1116                         break;
1117                     }
1118                   break;
1119                 case 0x10:
1120                     GETBYTE ();
1121                     switch (op[3] & 0x00)
1122                     {
1123                       case 0x00:
1124                         op_semantics_16:
1125                           {
1126                             /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg    %1%S1, %0 */
1127 #line 411 "rx-decode.opc"
1128                             int mx AU = (op[1] >> 6) & 0x03;
1129 #line 411 "rx-decode.opc"
1130                             int ss AU = op[1] & 0x03;
1131 #line 411 "rx-decode.opc"
1132                             int rsrc AU = (op[3] >> 4) & 0x0f;
1133 #line 411 "rx-decode.opc"
1134                             int rdst AU = op[3] & 0x0f;
1135                             if (trace)
1136                               {
1137                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1138                                        "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst     xchg    %1%S1, %0 */",
1139                                        op[0], op[1], op[2], op[3]);
1140                                 printf ("  mx = 0x%x,", mx);
1141                                 printf ("  ss = 0x%x,", ss);
1142                                 printf ("  rsrc = 0x%x,", rsrc);
1143                                 printf ("  rdst = 0x%x\n", rdst);
1144                               }
1145                             SYNTAX("xchg        %1%S1, %0");
1146 #line 411 "rx-decode.opc"
1147                             ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1148
1149                           /*----------------------------------------------------------------------*/
1150                           /* STZ/STNZ                                                           */
1151
1152                           }
1153                         break;
1154                     }
1155                   break;
1156                 case 0x11:
1157                     GETBYTE ();
1158                     switch (op[3] & 0x00)
1159                     {
1160                       case 0x00:
1161                         op_semantics_17:
1162                           {
1163                             /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof    %1%S1, %0 */
1164 #line 954 "rx-decode.opc"
1165                             int mx AU = (op[1] >> 6) & 0x03;
1166 #line 954 "rx-decode.opc"
1167                             int sd AU = op[1] & 0x03;
1168 #line 954 "rx-decode.opc"
1169                             int rsrc AU = (op[3] >> 4) & 0x0f;
1170 #line 954 "rx-decode.opc"
1171                             int rdst AU = op[3] & 0x0f;
1172                             if (trace)
1173                               {
1174                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1175                                        "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst     itof    %1%S1, %0 */",
1176                                        op[0], op[1], op[2], op[3]);
1177                                 printf ("  mx = 0x%x,", mx);
1178                                 printf ("  sd = 0x%x,", sd);
1179                                 printf ("  rsrc = 0x%x,", rsrc);
1180                                 printf ("  rdst = 0x%x\n", rdst);
1181                               }
1182                             SYNTAX("itof        %1%S1, %0");
1183 #line 954 "rx-decode.opc"
1184                             ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1185
1186                           /*----------------------------------------------------------------------*/
1187                           /* BIT OPS                                                            */
1188
1189                           }
1190                         break;
1191                     }
1192                   break;
1193                 case 0x15:
1194                     GETBYTE ();
1195                     switch (op[3] & 0x00)
1196                     {
1197                       case 0x00:
1198                         op_semantics_18:
1199                           {
1200                             /** 0000 0110 mx10 00sd 0001 0101 rsrc rdst utof    %1%S1, %0 */
1201 #line 1140 "rx-decode.opc"
1202                             int mx AU = (op[1] >> 6) & 0x03;
1203 #line 1140 "rx-decode.opc"
1204                             int sd AU = op[1] & 0x03;
1205 #line 1140 "rx-decode.opc"
1206                             int rsrc AU = (op[3] >> 4) & 0x0f;
1207 #line 1140 "rx-decode.opc"
1208                             int rdst AU = op[3] & 0x0f;
1209                             if (trace)
1210                               {
1211                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
1212                                        "/** 0000 0110 mx10 00sd 0001 0101 rsrc rdst     utof    %1%S1, %0 */",
1213                                        op[0], op[1], op[2], op[3]);
1214                                 printf ("  mx = 0x%x,", mx);
1215                                 printf ("  sd = 0x%x,", sd);
1216                                 printf ("  rsrc = 0x%x,", rsrc);
1217                                 printf ("  rdst = 0x%x\n", rdst);
1218                               }
1219                             SYNTAX("utof        %1%S1, %0");
1220 #line 1140 "rx-decode.opc"
1221                             ID(utof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1222
1223                           /*----------------------------------------------------------------------*/
1224                           /* RXv3 enhanced                                                      */
1225
1226                           }
1227                         break;
1228                     }
1229                   break;
1230                 default: UNSUPPORTED(); break;
1231               }
1232             break;
1233           case 0x21:
1234               GETBYTE ();
1235               switch (op[2] & 0xff)
1236               {
1237                 case 0x00:
1238                     GETBYTE ();
1239                     switch (op[3] & 0x00)
1240                     {
1241                       case 0x00:
1242                         goto op_semantics_7;
1243                         break;
1244                     }
1245                   break;
1246                 case 0x04:
1247                     GETBYTE ();
1248                     switch (op[3] & 0x00)
1249                     {
1250                       case 0x00:
1251                         goto op_semantics_8;
1252                         break;
1253                     }
1254                   break;
1255                 case 0x05:
1256                     GETBYTE ();
1257                     switch (op[3] & 0x00)
1258                     {
1259                       case 0x00:
1260                         goto op_semantics_9;
1261                         break;
1262                     }
1263                   break;
1264                 case 0x06:
1265                     GETBYTE ();
1266                     switch (op[3] & 0x00)
1267                     {
1268                       case 0x00:
1269                         goto op_semantics_10;
1270                         break;
1271                     }
1272                   break;
1273                 case 0x07:
1274                     GETBYTE ();
1275                     switch (op[3] & 0x00)
1276                     {
1277                       case 0x00:
1278                         goto op_semantics_11;
1279                         break;
1280                     }
1281                   break;
1282                 case 0x08:
1283                     GETBYTE ();
1284                     switch (op[3] & 0x00)
1285                     {
1286                       case 0x00:
1287                         goto op_semantics_12;
1288                         break;
1289                     }
1290                   break;
1291                 case 0x09:
1292                     GETBYTE ();
1293                     switch (op[3] & 0x00)
1294                     {
1295                       case 0x00:
1296                         goto op_semantics_13;
1297                         break;
1298                     }
1299                   break;
1300                 case 0x0c:
1301                     GETBYTE ();
1302                     switch (op[3] & 0x00)
1303                     {
1304                       case 0x00:
1305                         goto op_semantics_14;
1306                         break;
1307                     }
1308                   break;
1309                 case 0x0d:
1310                     GETBYTE ();
1311                     switch (op[3] & 0x00)
1312                     {
1313                       case 0x00:
1314                         goto op_semantics_15;
1315                         break;
1316                     }
1317                   break;
1318                 case 0x10:
1319                     GETBYTE ();
1320                     switch (op[3] & 0x00)
1321                     {
1322                       case 0x00:
1323                         goto op_semantics_16;
1324                         break;
1325                     }
1326                   break;
1327                 case 0x11:
1328                     GETBYTE ();
1329                     switch (op[3] & 0x00)
1330                     {
1331                       case 0x00:
1332                         goto op_semantics_17;
1333                         break;
1334                     }
1335                   break;
1336                 case 0x15:
1337                     GETBYTE ();
1338                     switch (op[3] & 0x00)
1339                     {
1340                       case 0x00:
1341                         goto op_semantics_18;
1342                         break;
1343                     }
1344                   break;
1345                 default: UNSUPPORTED(); break;
1346               }
1347             break;
1348           case 0x22:
1349               GETBYTE ();
1350               switch (op[2] & 0xff)
1351               {
1352                 case 0x00:
1353                     GETBYTE ();
1354                     switch (op[3] & 0x00)
1355                     {
1356                       case 0x00:
1357                         goto op_semantics_7;
1358                         break;
1359                     }
1360                   break;
1361                 case 0x04:
1362                     GETBYTE ();
1363                     switch (op[3] & 0x00)
1364                     {
1365                       case 0x00:
1366                         goto op_semantics_8;
1367                         break;
1368                     }
1369                   break;
1370                 case 0x05:
1371                     GETBYTE ();
1372                     switch (op[3] & 0x00)
1373                     {
1374                       case 0x00:
1375                         goto op_semantics_9;
1376                         break;
1377                     }
1378                   break;
1379                 case 0x06:
1380                     GETBYTE ();
1381                     switch (op[3] & 0x00)
1382                     {
1383                       case 0x00:
1384                         goto op_semantics_10;
1385                         break;
1386                     }
1387                   break;
1388                 case 0x07:
1389                     GETBYTE ();
1390                     switch (op[3] & 0x00)
1391                     {
1392                       case 0x00:
1393                         goto op_semantics_11;
1394                         break;
1395                     }
1396                   break;
1397                 case 0x08:
1398                     GETBYTE ();
1399                     switch (op[3] & 0x00)
1400                     {
1401                       case 0x00:
1402                         goto op_semantics_12;
1403                         break;
1404                     }
1405                   break;
1406                 case 0x09:
1407                     GETBYTE ();
1408                     switch (op[3] & 0x00)
1409                     {
1410                       case 0x00:
1411                         goto op_semantics_13;
1412                         break;
1413                     }
1414                   break;
1415                 case 0x0c:
1416                     GETBYTE ();
1417                     switch (op[3] & 0x00)
1418                     {
1419                       case 0x00:
1420                         goto op_semantics_14;
1421                         break;
1422                     }
1423                   break;
1424                 case 0x0d:
1425                     GETBYTE ();
1426                     switch (op[3] & 0x00)
1427                     {
1428                       case 0x00:
1429                         goto op_semantics_15;
1430                         break;
1431                     }
1432                   break;
1433                 case 0x10:
1434                     GETBYTE ();
1435                     switch (op[3] & 0x00)
1436                     {
1437                       case 0x00:
1438                         goto op_semantics_16;
1439                         break;
1440                     }
1441                   break;
1442                 case 0x11:
1443                     GETBYTE ();
1444                     switch (op[3] & 0x00)
1445                     {
1446                       case 0x00:
1447                         goto op_semantics_17;
1448                         break;
1449                     }
1450                   break;
1451                 case 0x15:
1452                     GETBYTE ();
1453                     switch (op[3] & 0x00)
1454                     {
1455                       case 0x00:
1456                         goto op_semantics_18;
1457                         break;
1458                     }
1459                   break;
1460                 default: UNSUPPORTED(); break;
1461               }
1462             break;
1463           case 0x23:
1464               GETBYTE ();
1465               switch (op[2] & 0xff)
1466               {
1467                 case 0x00:
1468                     GETBYTE ();
1469                     switch (op[3] & 0x00)
1470                     {
1471                       case 0x00:
1472                         goto op_semantics_7;
1473                         break;
1474                     }
1475                   break;
1476                 case 0x04:
1477                     GETBYTE ();
1478                     switch (op[3] & 0x00)
1479                     {
1480                       case 0x00:
1481                         goto op_semantics_8;
1482                         break;
1483                     }
1484                   break;
1485                 case 0x05:
1486                     GETBYTE ();
1487                     switch (op[3] & 0x00)
1488                     {
1489                       case 0x00:
1490                         goto op_semantics_9;
1491                         break;
1492                     }
1493                   break;
1494                 case 0x06:
1495                     GETBYTE ();
1496                     switch (op[3] & 0x00)
1497                     {
1498                       case 0x00:
1499                         goto op_semantics_10;
1500                         break;
1501                     }
1502                   break;
1503                 case 0x07:
1504                     GETBYTE ();
1505                     switch (op[3] & 0x00)
1506                     {
1507                       case 0x00:
1508                         goto op_semantics_11;
1509                         break;
1510                     }
1511                   break;
1512                 case 0x08:
1513                     GETBYTE ();
1514                     switch (op[3] & 0x00)
1515                     {
1516                       case 0x00:
1517                         goto op_semantics_12;
1518                         break;
1519                     }
1520                   break;
1521                 case 0x09:
1522                     GETBYTE ();
1523                     switch (op[3] & 0x00)
1524                     {
1525                       case 0x00:
1526                         goto op_semantics_13;
1527                         break;
1528                     }
1529                   break;
1530                 case 0x0c:
1531                     GETBYTE ();
1532                     switch (op[3] & 0x00)
1533                     {
1534                       case 0x00:
1535                         goto op_semantics_14;
1536                         break;
1537                     }
1538                   break;
1539                 case 0x0d:
1540                     GETBYTE ();
1541                     switch (op[3] & 0x00)
1542                     {
1543                       case 0x00:
1544                         goto op_semantics_15;
1545                         break;
1546                     }
1547                   break;
1548                 case 0x10:
1549                     GETBYTE ();
1550                     switch (op[3] & 0x00)
1551                     {
1552                       case 0x00:
1553                         goto op_semantics_16;
1554                         break;
1555                     }
1556                   break;
1557                 case 0x11:
1558                     GETBYTE ();
1559                     switch (op[3] & 0x00)
1560                     {
1561                       case 0x00:
1562                         goto op_semantics_17;
1563                         break;
1564                     }
1565                   break;
1566                 case 0x15:
1567                     GETBYTE ();
1568                     switch (op[3] & 0x00)
1569                     {
1570                       case 0x00:
1571                         goto op_semantics_18;
1572                         break;
1573                     }
1574                   break;
1575                 default: UNSUPPORTED(); break;
1576               }
1577             break;
1578           case 0x40:
1579               GETBYTE ();
1580               switch (op[2] & 0x00)
1581               {
1582                 case 0x00:
1583                   goto op_semantics_1;
1584                   break;
1585               }
1586             break;
1587           case 0x41:
1588               GETBYTE ();
1589               switch (op[2] & 0x00)
1590               {
1591                 case 0x00:
1592                   goto op_semantics_1;
1593                   break;
1594               }
1595             break;
1596           case 0x42:
1597               GETBYTE ();
1598               switch (op[2] & 0x00)
1599               {
1600                 case 0x00:
1601                   goto op_semantics_1;
1602                   break;
1603               }
1604             break;
1605           case 0x43:
1606               GETBYTE ();
1607               switch (op[2] & 0x00)
1608               {
1609                 case 0x00:
1610                   goto op_semantics_1;
1611                   break;
1612               }
1613             break;
1614           case 0x44:
1615               GETBYTE ();
1616               switch (op[2] & 0x00)
1617               {
1618                 case 0x00:
1619                   goto op_semantics_2;
1620                   break;
1621               }
1622             break;
1623           case 0x45:
1624               GETBYTE ();
1625               switch (op[2] & 0x00)
1626               {
1627                 case 0x00:
1628                   goto op_semantics_2;
1629                   break;
1630               }
1631             break;
1632           case 0x46:
1633               GETBYTE ();
1634               switch (op[2] & 0x00)
1635               {
1636                 case 0x00:
1637                   goto op_semantics_2;
1638                   break;
1639               }
1640             break;
1641           case 0x47:
1642               GETBYTE ();
1643               switch (op[2] & 0x00)
1644               {
1645                 case 0x00:
1646                   goto op_semantics_2;
1647                   break;
1648               }
1649             break;
1650           case 0x48:
1651               GETBYTE ();
1652               switch (op[2] & 0x00)
1653               {
1654                 case 0x00:
1655                   goto op_semantics_3;
1656                   break;
1657               }
1658             break;
1659           case 0x49:
1660               GETBYTE ();
1661               switch (op[2] & 0x00)
1662               {
1663                 case 0x00:
1664                   goto op_semantics_3;
1665                   break;
1666               }
1667             break;
1668           case 0x4a:
1669               GETBYTE ();
1670               switch (op[2] & 0x00)
1671               {
1672                 case 0x00:
1673                   goto op_semantics_3;
1674                   break;
1675               }
1676             break;
1677           case 0x4b:
1678               GETBYTE ();
1679               switch (op[2] & 0x00)
1680               {
1681                 case 0x00:
1682                   goto op_semantics_3;
1683                   break;
1684               }
1685             break;
1686           case 0x4c:
1687               GETBYTE ();
1688               switch (op[2] & 0x00)
1689               {
1690                 case 0x00:
1691                   goto op_semantics_4;
1692                   break;
1693               }
1694             break;
1695           case 0x4d:
1696               GETBYTE ();
1697               switch (op[2] & 0x00)
1698               {
1699                 case 0x00:
1700                   goto op_semantics_4;
1701                   break;
1702               }
1703             break;
1704           case 0x4e:
1705               GETBYTE ();
1706               switch (op[2] & 0x00)
1707               {
1708                 case 0x00:
1709                   goto op_semantics_4;
1710                   break;
1711               }
1712             break;
1713           case 0x4f:
1714               GETBYTE ();
1715               switch (op[2] & 0x00)
1716               {
1717                 case 0x00:
1718                   goto op_semantics_4;
1719                   break;
1720               }
1721             break;
1722           case 0x50:
1723               GETBYTE ();
1724               switch (op[2] & 0x00)
1725               {
1726                 case 0x00:
1727                   goto op_semantics_5;
1728                   break;
1729               }
1730             break;
1731           case 0x51:
1732               GETBYTE ();
1733               switch (op[2] & 0x00)
1734               {
1735                 case 0x00:
1736                   goto op_semantics_5;
1737                   break;
1738               }
1739             break;
1740           case 0x52:
1741               GETBYTE ();
1742               switch (op[2] & 0x00)
1743               {
1744                 case 0x00:
1745                   goto op_semantics_5;
1746                   break;
1747               }
1748             break;
1749           case 0x53:
1750               GETBYTE ();
1751               switch (op[2] & 0x00)
1752               {
1753                 case 0x00:
1754                   goto op_semantics_5;
1755                   break;
1756               }
1757             break;
1758           case 0x54:
1759               GETBYTE ();
1760               switch (op[2] & 0x00)
1761               {
1762                 case 0x00:
1763                   goto op_semantics_6;
1764                   break;
1765               }
1766             break;
1767           case 0x55:
1768               GETBYTE ();
1769               switch (op[2] & 0x00)
1770               {
1771                 case 0x00:
1772                   goto op_semantics_6;
1773                   break;
1774               }
1775             break;
1776           case 0x56:
1777               GETBYTE ();
1778               switch (op[2] & 0x00)
1779               {
1780                 case 0x00:
1781                   goto op_semantics_6;
1782                   break;
1783               }
1784             break;
1785           case 0x57:
1786               GETBYTE ();
1787               switch (op[2] & 0x00)
1788               {
1789                 case 0x00:
1790                   goto op_semantics_6;
1791                   break;
1792               }
1793             break;
1794           case 0x60:
1795               GETBYTE ();
1796               switch (op[2] & 0xff)
1797               {
1798                 case 0x00:
1799                     GETBYTE ();
1800                     switch (op[3] & 0x00)
1801                     {
1802                       case 0x00:
1803                         goto op_semantics_7;
1804                         break;
1805                     }
1806                   break;
1807                 case 0x04:
1808                     GETBYTE ();
1809                     switch (op[3] & 0x00)
1810                     {
1811                       case 0x00:
1812                         goto op_semantics_8;
1813                         break;
1814                     }
1815                   break;
1816                 case 0x05:
1817                     GETBYTE ();
1818                     switch (op[3] & 0x00)
1819                     {
1820                       case 0x00:
1821                         goto op_semantics_9;
1822                         break;
1823                     }
1824                   break;
1825                 case 0x06:
1826                     GETBYTE ();
1827                     switch (op[3] & 0x00)
1828                     {
1829                       case 0x00:
1830                         goto op_semantics_10;
1831                         break;
1832                     }
1833                   break;
1834                 case 0x07:
1835                     GETBYTE ();
1836                     switch (op[3] & 0x00)
1837                     {
1838                       case 0x00:
1839                         goto op_semantics_11;
1840                         break;
1841                     }
1842                   break;
1843                 case 0x08:
1844                     GETBYTE ();
1845                     switch (op[3] & 0x00)
1846                     {
1847                       case 0x00:
1848                         goto op_semantics_12;
1849                         break;
1850                     }
1851                   break;
1852                 case 0x09:
1853                     GETBYTE ();
1854                     switch (op[3] & 0x00)
1855                     {
1856                       case 0x00:
1857                         goto op_semantics_13;
1858                         break;
1859                     }
1860                   break;
1861                 case 0x0c:
1862                     GETBYTE ();
1863                     switch (op[3] & 0x00)
1864                     {
1865                       case 0x00:
1866                         goto op_semantics_14;
1867                         break;
1868                     }
1869                   break;
1870                 case 0x0d:
1871                     GETBYTE ();
1872                     switch (op[3] & 0x00)
1873                     {
1874                       case 0x00:
1875                         goto op_semantics_15;
1876                         break;
1877                     }
1878                   break;
1879                 case 0x10:
1880                     GETBYTE ();
1881                     switch (op[3] & 0x00)
1882                     {
1883                       case 0x00:
1884                         goto op_semantics_16;
1885                         break;
1886                     }
1887                   break;
1888                 case 0x11:
1889                     GETBYTE ();
1890                     switch (op[3] & 0x00)
1891                     {
1892                       case 0x00:
1893                         goto op_semantics_17;
1894                         break;
1895                     }
1896                   break;
1897                 case 0x15:
1898                     GETBYTE ();
1899                     switch (op[3] & 0x00)
1900                     {
1901                       case 0x00:
1902                         goto op_semantics_18;
1903                         break;
1904                     }
1905                   break;
1906                 default: UNSUPPORTED(); break;
1907               }
1908             break;
1909           case 0x61:
1910               GETBYTE ();
1911               switch (op[2] & 0xff)
1912               {
1913                 case 0x00:
1914                     GETBYTE ();
1915                     switch (op[3] & 0x00)
1916                     {
1917                       case 0x00:
1918                         goto op_semantics_7;
1919                         break;
1920                     }
1921                   break;
1922                 case 0x04:
1923                     GETBYTE ();
1924                     switch (op[3] & 0x00)
1925                     {
1926                       case 0x00:
1927                         goto op_semantics_8;
1928                         break;
1929                     }
1930                   break;
1931                 case 0x05:
1932                     GETBYTE ();
1933                     switch (op[3] & 0x00)
1934                     {
1935                       case 0x00:
1936                         goto op_semantics_9;
1937                         break;
1938                     }
1939                   break;
1940                 case 0x06:
1941                     GETBYTE ();
1942                     switch (op[3] & 0x00)
1943                     {
1944                       case 0x00:
1945                         goto op_semantics_10;
1946                         break;
1947                     }
1948                   break;
1949                 case 0x07:
1950                     GETBYTE ();
1951                     switch (op[3] & 0x00)
1952                     {
1953                       case 0x00:
1954                         goto op_semantics_11;
1955                         break;
1956                     }
1957                   break;
1958                 case 0x08:
1959                     GETBYTE ();
1960                     switch (op[3] & 0x00)
1961                     {
1962                       case 0x00:
1963                         goto op_semantics_12;
1964                         break;
1965                     }
1966                   break;
1967                 case 0x09:
1968                     GETBYTE ();
1969                     switch (op[3] & 0x00)
1970                     {
1971                       case 0x00:
1972                         goto op_semantics_13;
1973                         break;
1974                     }
1975                   break;
1976                 case 0x0c:
1977                     GETBYTE ();
1978                     switch (op[3] & 0x00)
1979                     {
1980                       case 0x00:
1981                         goto op_semantics_14;
1982                         break;
1983                     }
1984                   break;
1985                 case 0x0d:
1986                     GETBYTE ();
1987                     switch (op[3] & 0x00)
1988                     {
1989                       case 0x00:
1990                         goto op_semantics_15;
1991                         break;
1992                     }
1993                   break;
1994                 case 0x10:
1995                     GETBYTE ();
1996                     switch (op[3] & 0x00)
1997                     {
1998                       case 0x00:
1999                         goto op_semantics_16;
2000                         break;
2001                     }
2002                   break;
2003                 case 0x11:
2004                     GETBYTE ();
2005                     switch (op[3] & 0x00)
2006                     {
2007                       case 0x00:
2008                         goto op_semantics_17;
2009                         break;
2010                     }
2011                   break;
2012                 case 0x15:
2013                     GETBYTE ();
2014                     switch (op[3] & 0x00)
2015                     {
2016                       case 0x00:
2017                         goto op_semantics_18;
2018                         break;
2019                     }
2020                   break;
2021                 default: UNSUPPORTED(); break;
2022               }
2023             break;
2024           case 0x62:
2025               GETBYTE ();
2026               switch (op[2] & 0xff)
2027               {
2028                 case 0x00:
2029                     GETBYTE ();
2030                     switch (op[3] & 0x00)
2031                     {
2032                       case 0x00:
2033                         goto op_semantics_7;
2034                         break;
2035                     }
2036                   break;
2037                 case 0x04:
2038                     GETBYTE ();
2039                     switch (op[3] & 0x00)
2040                     {
2041                       case 0x00:
2042                         goto op_semantics_8;
2043                         break;
2044                     }
2045                   break;
2046                 case 0x05:
2047                     GETBYTE ();
2048                     switch (op[3] & 0x00)
2049                     {
2050                       case 0x00:
2051                         goto op_semantics_9;
2052                         break;
2053                     }
2054                   break;
2055                 case 0x06:
2056                     GETBYTE ();
2057                     switch (op[3] & 0x00)
2058                     {
2059                       case 0x00:
2060                         goto op_semantics_10;
2061                         break;
2062                     }
2063                   break;
2064                 case 0x07:
2065                     GETBYTE ();
2066                     switch (op[3] & 0x00)
2067                     {
2068                       case 0x00:
2069                         goto op_semantics_11;
2070                         break;
2071                     }
2072                   break;
2073                 case 0x08:
2074                     GETBYTE ();
2075                     switch (op[3] & 0x00)
2076                     {
2077                       case 0x00:
2078                         goto op_semantics_12;
2079                         break;
2080                     }
2081                   break;
2082                 case 0x09:
2083                     GETBYTE ();
2084                     switch (op[3] & 0x00)
2085                     {
2086                       case 0x00:
2087                         goto op_semantics_13;
2088                         break;
2089                     }
2090                   break;
2091                 case 0x0c:
2092                     GETBYTE ();
2093                     switch (op[3] & 0x00)
2094                     {
2095                       case 0x00:
2096                         goto op_semantics_14;
2097                         break;
2098                     }
2099                   break;
2100                 case 0x0d:
2101                     GETBYTE ();
2102                     switch (op[3] & 0x00)
2103                     {
2104                       case 0x00:
2105                         goto op_semantics_15;
2106                         break;
2107                     }
2108                   break;
2109                 case 0x10:
2110                     GETBYTE ();
2111                     switch (op[3] & 0x00)
2112                     {
2113                       case 0x00:
2114                         goto op_semantics_16;
2115                         break;
2116                     }
2117                   break;
2118                 case 0x11:
2119                     GETBYTE ();
2120                     switch (op[3] & 0x00)
2121                     {
2122                       case 0x00:
2123                         goto op_semantics_17;
2124                         break;
2125                     }
2126                   break;
2127                 case 0x15:
2128                     GETBYTE ();
2129                     switch (op[3] & 0x00)
2130                     {
2131                       case 0x00:
2132                         goto op_semantics_18;
2133                         break;
2134                     }
2135                   break;
2136                 default: UNSUPPORTED(); break;
2137               }
2138             break;
2139           case 0x63:
2140               GETBYTE ();
2141               switch (op[2] & 0xff)
2142               {
2143                 case 0x00:
2144                     GETBYTE ();
2145                     switch (op[3] & 0x00)
2146                     {
2147                       case 0x00:
2148                         goto op_semantics_7;
2149                         break;
2150                     }
2151                   break;
2152                 case 0x04:
2153                     GETBYTE ();
2154                     switch (op[3] & 0x00)
2155                     {
2156                       case 0x00:
2157                         goto op_semantics_8;
2158                         break;
2159                     }
2160                   break;
2161                 case 0x05:
2162                     GETBYTE ();
2163                     switch (op[3] & 0x00)
2164                     {
2165                       case 0x00:
2166                         goto op_semantics_9;
2167                         break;
2168                     }
2169                   break;
2170                 case 0x06:
2171                     GETBYTE ();
2172                     switch (op[3] & 0x00)
2173                     {
2174                       case 0x00:
2175                         goto op_semantics_10;
2176                         break;
2177                     }
2178                   break;
2179                 case 0x07:
2180                     GETBYTE ();
2181                     switch (op[3] & 0x00)
2182                     {
2183                       case 0x00:
2184                         goto op_semantics_11;
2185                         break;
2186                     }
2187                   break;
2188                 case 0x08:
2189                     GETBYTE ();
2190                     switch (op[3] & 0x00)
2191                     {
2192                       case 0x00:
2193                         goto op_semantics_12;
2194                         break;
2195                     }
2196                   break;
2197                 case 0x09:
2198                     GETBYTE ();
2199                     switch (op[3] & 0x00)
2200                     {
2201                       case 0x00:
2202                         goto op_semantics_13;
2203                         break;
2204                     }
2205                   break;
2206                 case 0x0c:
2207                     GETBYTE ();
2208                     switch (op[3] & 0x00)
2209                     {
2210                       case 0x00:
2211                         goto op_semantics_14;
2212                         break;
2213                     }
2214                   break;
2215                 case 0x0d:
2216                     GETBYTE ();
2217                     switch (op[3] & 0x00)
2218                     {
2219                       case 0x00:
2220                         goto op_semantics_15;
2221                         break;
2222                     }
2223                   break;
2224                 case 0x10:
2225                     GETBYTE ();
2226                     switch (op[3] & 0x00)
2227                     {
2228                       case 0x00:
2229                         goto op_semantics_16;
2230                         break;
2231                     }
2232                   break;
2233                 case 0x11:
2234                     GETBYTE ();
2235                     switch (op[3] & 0x00)
2236                     {
2237                       case 0x00:
2238                         goto op_semantics_17;
2239                         break;
2240                     }
2241                   break;
2242                 case 0x15:
2243                     GETBYTE ();
2244                     switch (op[3] & 0x00)
2245                     {
2246                       case 0x00:
2247                         goto op_semantics_18;
2248                         break;
2249                     }
2250                   break;
2251                 default: UNSUPPORTED(); break;
2252               }
2253             break;
2254           case 0x80:
2255               GETBYTE ();
2256               switch (op[2] & 0x00)
2257               {
2258                 case 0x00:
2259                   goto op_semantics_1;
2260                   break;
2261               }
2262             break;
2263           case 0x81:
2264               GETBYTE ();
2265               switch (op[2] & 0x00)
2266               {
2267                 case 0x00:
2268                   goto op_semantics_1;
2269                   break;
2270               }
2271             break;
2272           case 0x82:
2273               GETBYTE ();
2274               switch (op[2] & 0x00)
2275               {
2276                 case 0x00:
2277                   goto op_semantics_1;
2278                   break;
2279               }
2280             break;
2281           case 0x83:
2282               GETBYTE ();
2283               switch (op[2] & 0x00)
2284               {
2285                 case 0x00:
2286                   goto op_semantics_1;
2287                   break;
2288               }
2289             break;
2290           case 0x84:
2291               GETBYTE ();
2292               switch (op[2] & 0x00)
2293               {
2294                 case 0x00:
2295                   goto op_semantics_2;
2296                   break;
2297               }
2298             break;
2299           case 0x85:
2300               GETBYTE ();
2301               switch (op[2] & 0x00)
2302               {
2303                 case 0x00:
2304                   goto op_semantics_2;
2305                   break;
2306               }
2307             break;
2308           case 0x86:
2309               GETBYTE ();
2310               switch (op[2] & 0x00)
2311               {
2312                 case 0x00:
2313                   goto op_semantics_2;
2314                   break;
2315               }
2316             break;
2317           case 0x87:
2318               GETBYTE ();
2319               switch (op[2] & 0x00)
2320               {
2321                 case 0x00:
2322                   goto op_semantics_2;
2323                   break;
2324               }
2325             break;
2326           case 0x88:
2327               GETBYTE ();
2328               switch (op[2] & 0x00)
2329               {
2330                 case 0x00:
2331                   goto op_semantics_3;
2332                   break;
2333               }
2334             break;
2335           case 0x89:
2336               GETBYTE ();
2337               switch (op[2] & 0x00)
2338               {
2339                 case 0x00:
2340                   goto op_semantics_3;
2341                   break;
2342               }
2343             break;
2344           case 0x8a:
2345               GETBYTE ();
2346               switch (op[2] & 0x00)
2347               {
2348                 case 0x00:
2349                   goto op_semantics_3;
2350                   break;
2351               }
2352             break;
2353           case 0x8b:
2354               GETBYTE ();
2355               switch (op[2] & 0x00)
2356               {
2357                 case 0x00:
2358                   goto op_semantics_3;
2359                   break;
2360               }
2361             break;
2362           case 0x8c:
2363               GETBYTE ();
2364               switch (op[2] & 0x00)
2365               {
2366                 case 0x00:
2367                   goto op_semantics_4;
2368                   break;
2369               }
2370             break;
2371           case 0x8d:
2372               GETBYTE ();
2373               switch (op[2] & 0x00)
2374               {
2375                 case 0x00:
2376                   goto op_semantics_4;
2377                   break;
2378               }
2379             break;
2380           case 0x8e:
2381               GETBYTE ();
2382               switch (op[2] & 0x00)
2383               {
2384                 case 0x00:
2385                   goto op_semantics_4;
2386                   break;
2387               }
2388             break;
2389           case 0x8f:
2390               GETBYTE ();
2391               switch (op[2] & 0x00)
2392               {
2393                 case 0x00:
2394                   goto op_semantics_4;
2395                   break;
2396               }
2397             break;
2398           case 0x90:
2399               GETBYTE ();
2400               switch (op[2] & 0x00)
2401               {
2402                 case 0x00:
2403                   goto op_semantics_5;
2404                   break;
2405               }
2406             break;
2407           case 0x91:
2408               GETBYTE ();
2409               switch (op[2] & 0x00)
2410               {
2411                 case 0x00:
2412                   goto op_semantics_5;
2413                   break;
2414               }
2415             break;
2416           case 0x92:
2417               GETBYTE ();
2418               switch (op[2] & 0x00)
2419               {
2420                 case 0x00:
2421                   goto op_semantics_5;
2422                   break;
2423               }
2424             break;
2425           case 0x93:
2426               GETBYTE ();
2427               switch (op[2] & 0x00)
2428               {
2429                 case 0x00:
2430                   goto op_semantics_5;
2431                   break;
2432               }
2433             break;
2434           case 0x94:
2435               GETBYTE ();
2436               switch (op[2] & 0x00)
2437               {
2438                 case 0x00:
2439                   goto op_semantics_6;
2440                   break;
2441               }
2442             break;
2443           case 0x95:
2444               GETBYTE ();
2445               switch (op[2] & 0x00)
2446               {
2447                 case 0x00:
2448                   goto op_semantics_6;
2449                   break;
2450               }
2451             break;
2452           case 0x96:
2453               GETBYTE ();
2454               switch (op[2] & 0x00)
2455               {
2456                 case 0x00:
2457                   goto op_semantics_6;
2458                   break;
2459               }
2460             break;
2461           case 0x97:
2462               GETBYTE ();
2463               switch (op[2] & 0x00)
2464               {
2465                 case 0x00:
2466                   goto op_semantics_6;
2467                   break;
2468               }
2469             break;
2470           case 0xa0:
2471               GETBYTE ();
2472               switch (op[2] & 0xff)
2473               {
2474                 case 0x00:
2475                     GETBYTE ();
2476                     switch (op[3] & 0x00)
2477                     {
2478                       case 0x00:
2479                         goto op_semantics_7;
2480                         break;
2481                     }
2482                   break;
2483                 case 0x02:
2484                     GETBYTE ();
2485                     switch (op[3] & 0x00)
2486                     {
2487                       case 0x00:
2488                         op_semantics_19:
2489                           {
2490                             /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc     %1%S1, %0 */
2491 #line 519 "rx-decode.opc"
2492                             int ss AU = op[1] & 0x03;
2493 #line 519 "rx-decode.opc"
2494                             int rsrc AU = (op[3] >> 4) & 0x0f;
2495 #line 519 "rx-decode.opc"
2496                             int rdst AU = op[3] & 0x0f;
2497                             if (trace)
2498                               {
2499                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
2500                                        "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst     adc     %1%S1, %0 */",
2501                                        op[0], op[1], op[2], op[3]);
2502                                 printf ("  ss = 0x%x,", ss);
2503                                 printf ("  rsrc = 0x%x,", rsrc);
2504                                 printf ("  rdst = 0x%x\n", rdst);
2505                               }
2506                             SYNTAX("adc %1%S1, %0");
2507 #line 519 "rx-decode.opc"
2508                             ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2509
2510                           /*----------------------------------------------------------------------*/
2511                           /* ADD                                                                        */
2512
2513                           }
2514                         break;
2515                     }
2516                   break;
2517                 case 0x04:
2518                     GETBYTE ();
2519                     switch (op[3] & 0x00)
2520                     {
2521                       case 0x00:
2522                         goto op_semantics_8;
2523                         break;
2524                     }
2525                   break;
2526                 case 0x05:
2527                     GETBYTE ();
2528                     switch (op[3] & 0x00)
2529                     {
2530                       case 0x00:
2531                         goto op_semantics_9;
2532                         break;
2533                     }
2534                   break;
2535                 case 0x06:
2536                     GETBYTE ();
2537                     switch (op[3] & 0x00)
2538                     {
2539                       case 0x00:
2540                         goto op_semantics_10;
2541                         break;
2542                     }
2543                   break;
2544                 case 0x07:
2545                     GETBYTE ();
2546                     switch (op[3] & 0x00)
2547                     {
2548                       case 0x00:
2549                         goto op_semantics_11;
2550                         break;
2551                     }
2552                   break;
2553                 case 0x08:
2554                     GETBYTE ();
2555                     switch (op[3] & 0x00)
2556                     {
2557                       case 0x00:
2558                         goto op_semantics_12;
2559                         break;
2560                     }
2561                   break;
2562                 case 0x09:
2563                     GETBYTE ();
2564                     switch (op[3] & 0x00)
2565                     {
2566                       case 0x00:
2567                         goto op_semantics_13;
2568                         break;
2569                     }
2570                   break;
2571                 case 0x0c:
2572                     GETBYTE ();
2573                     switch (op[3] & 0x00)
2574                     {
2575                       case 0x00:
2576                         goto op_semantics_14;
2577                         break;
2578                     }
2579                   break;
2580                 case 0x0d:
2581                     GETBYTE ();
2582                     switch (op[3] & 0x00)
2583                     {
2584                       case 0x00:
2585                         goto op_semantics_15;
2586                         break;
2587                     }
2588                   break;
2589                 case 0x10:
2590                     GETBYTE ();
2591                     switch (op[3] & 0x00)
2592                     {
2593                       case 0x00:
2594                         goto op_semantics_16;
2595                         break;
2596                     }
2597                   break;
2598                 case 0x11:
2599                     GETBYTE ();
2600                     switch (op[3] & 0x00)
2601                     {
2602                       case 0x00:
2603                         goto op_semantics_17;
2604                         break;
2605                     }
2606                   break;
2607                 case 0x15:
2608                     GETBYTE ();
2609                     switch (op[3] & 0x00)
2610                     {
2611                       case 0x00:
2612                         goto op_semantics_18;
2613                         break;
2614                     }
2615                   break;
2616                 default: UNSUPPORTED(); break;
2617               }
2618             break;
2619           case 0xa1:
2620               GETBYTE ();
2621               switch (op[2] & 0xff)
2622               {
2623                 case 0x00:
2624                     GETBYTE ();
2625                     switch (op[3] & 0x00)
2626                     {
2627                       case 0x00:
2628                         goto op_semantics_7;
2629                         break;
2630                     }
2631                   break;
2632                 case 0x02:
2633                     GETBYTE ();
2634                     switch (op[3] & 0x00)
2635                     {
2636                       case 0x00:
2637                         goto op_semantics_19;
2638                         break;
2639                     }
2640                   break;
2641                 case 0x04:
2642                     GETBYTE ();
2643                     switch (op[3] & 0x00)
2644                     {
2645                       case 0x00:
2646                         goto op_semantics_8;
2647                         break;
2648                     }
2649                   break;
2650                 case 0x05:
2651                     GETBYTE ();
2652                     switch (op[3] & 0x00)
2653                     {
2654                       case 0x00:
2655                         goto op_semantics_9;
2656                         break;
2657                     }
2658                   break;
2659                 case 0x06:
2660                     GETBYTE ();
2661                     switch (op[3] & 0x00)
2662                     {
2663                       case 0x00:
2664                         goto op_semantics_10;
2665                         break;
2666                     }
2667                   break;
2668                 case 0x07:
2669                     GETBYTE ();
2670                     switch (op[3] & 0x00)
2671                     {
2672                       case 0x00:
2673                         goto op_semantics_11;
2674                         break;
2675                     }
2676                   break;
2677                 case 0x08:
2678                     GETBYTE ();
2679                     switch (op[3] & 0x00)
2680                     {
2681                       case 0x00:
2682                         goto op_semantics_12;
2683                         break;
2684                     }
2685                   break;
2686                 case 0x09:
2687                     GETBYTE ();
2688                     switch (op[3] & 0x00)
2689                     {
2690                       case 0x00:
2691                         goto op_semantics_13;
2692                         break;
2693                     }
2694                   break;
2695                 case 0x0c:
2696                     GETBYTE ();
2697                     switch (op[3] & 0x00)
2698                     {
2699                       case 0x00:
2700                         goto op_semantics_14;
2701                         break;
2702                     }
2703                   break;
2704                 case 0x0d:
2705                     GETBYTE ();
2706                     switch (op[3] & 0x00)
2707                     {
2708                       case 0x00:
2709                         goto op_semantics_15;
2710                         break;
2711                     }
2712                   break;
2713                 case 0x10:
2714                     GETBYTE ();
2715                     switch (op[3] & 0x00)
2716                     {
2717                       case 0x00:
2718                         goto op_semantics_16;
2719                         break;
2720                     }
2721                   break;
2722                 case 0x11:
2723                     GETBYTE ();
2724                     switch (op[3] & 0x00)
2725                     {
2726                       case 0x00:
2727                         goto op_semantics_17;
2728                         break;
2729                     }
2730                   break;
2731                 case 0x15:
2732                     GETBYTE ();
2733                     switch (op[3] & 0x00)
2734                     {
2735                       case 0x00:
2736                         goto op_semantics_18;
2737                         break;
2738                     }
2739                   break;
2740                 default: UNSUPPORTED(); break;
2741               }
2742             break;
2743           case 0xa2:
2744               GETBYTE ();
2745               switch (op[2] & 0xff)
2746               {
2747                 case 0x00:
2748                     GETBYTE ();
2749                     switch (op[3] & 0x00)
2750                     {
2751                       case 0x00:
2752                         goto op_semantics_7;
2753                         break;
2754                     }
2755                   break;
2756                 case 0x02:
2757                     GETBYTE ();
2758                     switch (op[3] & 0x00)
2759                     {
2760                       case 0x00:
2761                         goto op_semantics_19;
2762                         break;
2763                     }
2764                   break;
2765                 case 0x04:
2766                     GETBYTE ();
2767                     switch (op[3] & 0x00)
2768                     {
2769                       case 0x00:
2770                         goto op_semantics_8;
2771                         break;
2772                     }
2773                   break;
2774                 case 0x05:
2775                     GETBYTE ();
2776                     switch (op[3] & 0x00)
2777                     {
2778                       case 0x00:
2779                         goto op_semantics_9;
2780                         break;
2781                     }
2782                   break;
2783                 case 0x06:
2784                     GETBYTE ();
2785                     switch (op[3] & 0x00)
2786                     {
2787                       case 0x00:
2788                         goto op_semantics_10;
2789                         break;
2790                     }
2791                   break;
2792                 case 0x07:
2793                     GETBYTE ();
2794                     switch (op[3] & 0x00)
2795                     {
2796                       case 0x00:
2797                         goto op_semantics_11;
2798                         break;
2799                     }
2800                   break;
2801                 case 0x08:
2802                     GETBYTE ();
2803                     switch (op[3] & 0x00)
2804                     {
2805                       case 0x00:
2806                         goto op_semantics_12;
2807                         break;
2808                     }
2809                   break;
2810                 case 0x09:
2811                     GETBYTE ();
2812                     switch (op[3] & 0x00)
2813                     {
2814                       case 0x00:
2815                         goto op_semantics_13;
2816                         break;
2817                     }
2818                   break;
2819                 case 0x0c:
2820                     GETBYTE ();
2821                     switch (op[3] & 0x00)
2822                     {
2823                       case 0x00:
2824                         goto op_semantics_14;
2825                         break;
2826                     }
2827                   break;
2828                 case 0x0d:
2829                     GETBYTE ();
2830                     switch (op[3] & 0x00)
2831                     {
2832                       case 0x00:
2833                         goto op_semantics_15;
2834                         break;
2835                     }
2836                   break;
2837                 case 0x10:
2838                     GETBYTE ();
2839                     switch (op[3] & 0x00)
2840                     {
2841                       case 0x00:
2842                         goto op_semantics_16;
2843                         break;
2844                     }
2845                   break;
2846                 case 0x11:
2847                     GETBYTE ();
2848                     switch (op[3] & 0x00)
2849                     {
2850                       case 0x00:
2851                         goto op_semantics_17;
2852                         break;
2853                     }
2854                   break;
2855                 case 0x15:
2856                     GETBYTE ();
2857                     switch (op[3] & 0x00)
2858                     {
2859                       case 0x00:
2860                         goto op_semantics_18;
2861                         break;
2862                     }
2863                   break;
2864                 default: UNSUPPORTED(); break;
2865               }
2866             break;
2867           case 0xa3:
2868               GETBYTE ();
2869               switch (op[2] & 0xff)
2870               {
2871                 case 0x00:
2872                     GETBYTE ();
2873                     switch (op[3] & 0x00)
2874                     {
2875                       case 0x00:
2876                         goto op_semantics_7;
2877                         break;
2878                     }
2879                   break;
2880                 case 0x02:
2881                     GETBYTE ();
2882                     switch (op[3] & 0x00)
2883                     {
2884                       case 0x00:
2885                         goto op_semantics_19;
2886                         break;
2887                     }
2888                   break;
2889                 case 0x04:
2890                     GETBYTE ();
2891                     switch (op[3] & 0x00)
2892                     {
2893                       case 0x00:
2894                         goto op_semantics_8;
2895                         break;
2896                     }
2897                   break;
2898                 case 0x05:
2899                     GETBYTE ();
2900                     switch (op[3] & 0x00)
2901                     {
2902                       case 0x00:
2903                         goto op_semantics_9;
2904                         break;
2905                     }
2906                   break;
2907                 case 0x06:
2908                     GETBYTE ();
2909                     switch (op[3] & 0x00)
2910                     {
2911                       case 0x00:
2912                         goto op_semantics_10;
2913                         break;
2914                     }
2915                   break;
2916                 case 0x07:
2917                     GETBYTE ();
2918                     switch (op[3] & 0x00)
2919                     {
2920                       case 0x00:
2921                         goto op_semantics_11;
2922                         break;
2923                     }
2924                   break;
2925                 case 0x08:
2926                     GETBYTE ();
2927                     switch (op[3] & 0x00)
2928                     {
2929                       case 0x00:
2930                         goto op_semantics_12;
2931                         break;
2932                     }
2933                   break;
2934                 case 0x09:
2935                     GETBYTE ();
2936                     switch (op[3] & 0x00)
2937                     {
2938                       case 0x00:
2939                         goto op_semantics_13;
2940                         break;
2941                     }
2942                   break;
2943                 case 0x0c:
2944                     GETBYTE ();
2945                     switch (op[3] & 0x00)
2946                     {
2947                       case 0x00:
2948                         goto op_semantics_14;
2949                         break;
2950                     }
2951                   break;
2952                 case 0x0d:
2953                     GETBYTE ();
2954                     switch (op[3] & 0x00)
2955                     {
2956                       case 0x00:
2957                         goto op_semantics_15;
2958                         break;
2959                     }
2960                   break;
2961                 case 0x10:
2962                     GETBYTE ();
2963                     switch (op[3] & 0x00)
2964                     {
2965                       case 0x00:
2966                         goto op_semantics_16;
2967                         break;
2968                     }
2969                   break;
2970                 case 0x11:
2971                     GETBYTE ();
2972                     switch (op[3] & 0x00)
2973                     {
2974                       case 0x00:
2975                         goto op_semantics_17;
2976                         break;
2977                     }
2978                   break;
2979                 case 0x15:
2980                     GETBYTE ();
2981                     switch (op[3] & 0x00)
2982                     {
2983                       case 0x00:
2984                         goto op_semantics_18;
2985                         break;
2986                     }
2987                   break;
2988                 default: UNSUPPORTED(); break;
2989               }
2990             break;
2991           case 0xc0:
2992               GETBYTE ();
2993               switch (op[2] & 0x00)
2994               {
2995                 case 0x00:
2996                   goto op_semantics_1;
2997                   break;
2998               }
2999             break;
3000           case 0xc1:
3001               GETBYTE ();
3002               switch (op[2] & 0x00)
3003               {
3004                 case 0x00:
3005                   goto op_semantics_1;
3006                   break;
3007               }
3008             break;
3009           case 0xc2:
3010               GETBYTE ();
3011               switch (op[2] & 0x00)
3012               {
3013                 case 0x00:
3014                   goto op_semantics_1;
3015                   break;
3016               }
3017             break;
3018           case 0xc3:
3019               GETBYTE ();
3020               switch (op[2] & 0x00)
3021               {
3022                 case 0x00:
3023                   goto op_semantics_1;
3024                   break;
3025               }
3026             break;
3027           case 0xc4:
3028               GETBYTE ();
3029               switch (op[2] & 0x00)
3030               {
3031                 case 0x00:
3032                   goto op_semantics_2;
3033                   break;
3034               }
3035             break;
3036           case 0xc5:
3037               GETBYTE ();
3038               switch (op[2] & 0x00)
3039               {
3040                 case 0x00:
3041                   goto op_semantics_2;
3042                   break;
3043               }
3044             break;
3045           case 0xc6:
3046               GETBYTE ();
3047               switch (op[2] & 0x00)
3048               {
3049                 case 0x00:
3050                   goto op_semantics_2;
3051                   break;
3052               }
3053             break;
3054           case 0xc7:
3055               GETBYTE ();
3056               switch (op[2] & 0x00)
3057               {
3058                 case 0x00:
3059                   goto op_semantics_2;
3060                   break;
3061               }
3062             break;
3063           case 0xc8:
3064               GETBYTE ();
3065               switch (op[2] & 0x00)
3066               {
3067                 case 0x00:
3068                   goto op_semantics_3;
3069                   break;
3070               }
3071             break;
3072           case 0xc9:
3073               GETBYTE ();
3074               switch (op[2] & 0x00)
3075               {
3076                 case 0x00:
3077                   goto op_semantics_3;
3078                   break;
3079               }
3080             break;
3081           case 0xca:
3082               GETBYTE ();
3083               switch (op[2] & 0x00)
3084               {
3085                 case 0x00:
3086                   goto op_semantics_3;
3087                   break;
3088               }
3089             break;
3090           case 0xcb:
3091               GETBYTE ();
3092               switch (op[2] & 0x00)
3093               {
3094                 case 0x00:
3095                   goto op_semantics_3;
3096                   break;
3097               }
3098             break;
3099           case 0xcc:
3100               GETBYTE ();
3101               switch (op[2] & 0x00)
3102               {
3103                 case 0x00:
3104                   goto op_semantics_4;
3105                   break;
3106               }
3107             break;
3108           case 0xcd:
3109               GETBYTE ();
3110               switch (op[2] & 0x00)
3111               {
3112                 case 0x00:
3113                   goto op_semantics_4;
3114                   break;
3115               }
3116             break;
3117           case 0xce:
3118               GETBYTE ();
3119               switch (op[2] & 0x00)
3120               {
3121                 case 0x00:
3122                   goto op_semantics_4;
3123                   break;
3124               }
3125             break;
3126           case 0xcf:
3127               GETBYTE ();
3128               switch (op[2] & 0x00)
3129               {
3130                 case 0x00:
3131                   goto op_semantics_4;
3132                   break;
3133               }
3134             break;
3135           case 0xd0:
3136               GETBYTE ();
3137               switch (op[2] & 0x00)
3138               {
3139                 case 0x00:
3140                   goto op_semantics_5;
3141                   break;
3142               }
3143             break;
3144           case 0xd1:
3145               GETBYTE ();
3146               switch (op[2] & 0x00)
3147               {
3148                 case 0x00:
3149                   goto op_semantics_5;
3150                   break;
3151               }
3152             break;
3153           case 0xd2:
3154               GETBYTE ();
3155               switch (op[2] & 0x00)
3156               {
3157                 case 0x00:
3158                   goto op_semantics_5;
3159                   break;
3160               }
3161             break;
3162           case 0xd3:
3163               GETBYTE ();
3164               switch (op[2] & 0x00)
3165               {
3166                 case 0x00:
3167                   goto op_semantics_5;
3168                   break;
3169               }
3170             break;
3171           case 0xd4:
3172               GETBYTE ();
3173               switch (op[2] & 0x00)
3174               {
3175                 case 0x00:
3176                   goto op_semantics_6;
3177                   break;
3178               }
3179             break;
3180           case 0xd5:
3181               GETBYTE ();
3182               switch (op[2] & 0x00)
3183               {
3184                 case 0x00:
3185                   goto op_semantics_6;
3186                   break;
3187               }
3188             break;
3189           case 0xd6:
3190               GETBYTE ();
3191               switch (op[2] & 0x00)
3192               {
3193                 case 0x00:
3194                   goto op_semantics_6;
3195                   break;
3196               }
3197             break;
3198           case 0xd7:
3199               GETBYTE ();
3200               switch (op[2] & 0x00)
3201               {
3202                 case 0x00:
3203                   goto op_semantics_6;
3204                   break;
3205               }
3206             break;
3207           case 0xe0:
3208               GETBYTE ();
3209               switch (op[2] & 0xff)
3210               {
3211                 case 0x00:
3212                     GETBYTE ();
3213                     switch (op[3] & 0x00)
3214                     {
3215                       case 0x00:
3216                         goto op_semantics_7;
3217                         break;
3218                     }
3219                   break;
3220                 case 0x04:
3221                     GETBYTE ();
3222                     switch (op[3] & 0x00)
3223                     {
3224                       case 0x00:
3225                         goto op_semantics_8;
3226                         break;
3227                     }
3228                   break;
3229                 case 0x05:
3230                     GETBYTE ();
3231                     switch (op[3] & 0x00)
3232                     {
3233                       case 0x00:
3234                         goto op_semantics_9;
3235                         break;
3236                     }
3237                   break;
3238                 case 0x06:
3239                     GETBYTE ();
3240                     switch (op[3] & 0x00)
3241                     {
3242                       case 0x00:
3243                         goto op_semantics_10;
3244                         break;
3245                     }
3246                   break;
3247                 case 0x07:
3248                     GETBYTE ();
3249                     switch (op[3] & 0x00)
3250                     {
3251                       case 0x00:
3252                         goto op_semantics_11;
3253                         break;
3254                     }
3255                   break;
3256                 case 0x08:
3257                     GETBYTE ();
3258                     switch (op[3] & 0x00)
3259                     {
3260                       case 0x00:
3261                         goto op_semantics_12;
3262                         break;
3263                     }
3264                   break;
3265                 case 0x09:
3266                     GETBYTE ();
3267                     switch (op[3] & 0x00)
3268                     {
3269                       case 0x00:
3270                         goto op_semantics_13;
3271                         break;
3272                     }
3273                   break;
3274                 case 0x0c:
3275                     GETBYTE ();
3276                     switch (op[3] & 0x00)
3277                     {
3278                       case 0x00:
3279                         goto op_semantics_14;
3280                         break;
3281                     }
3282                   break;
3283                 case 0x0d:
3284                     GETBYTE ();
3285                     switch (op[3] & 0x00)
3286                     {
3287                       case 0x00:
3288                         goto op_semantics_15;
3289                         break;
3290                     }
3291                   break;
3292                 case 0x10:
3293                     GETBYTE ();
3294                     switch (op[3] & 0x00)
3295                     {
3296                       case 0x00:
3297                         goto op_semantics_16;
3298                         break;
3299                     }
3300                   break;
3301                 case 0x11:
3302                     GETBYTE ();
3303                     switch (op[3] & 0x00)
3304                     {
3305                       case 0x00:
3306                         goto op_semantics_17;
3307                         break;
3308                     }
3309                   break;
3310                 case 0x15:
3311                     GETBYTE ();
3312                     switch (op[3] & 0x00)
3313                     {
3314                       case 0x00:
3315                         goto op_semantics_18;
3316                         break;
3317                     }
3318                   break;
3319                 default: UNSUPPORTED(); break;
3320               }
3321             break;
3322           case 0xe1:
3323               GETBYTE ();
3324               switch (op[2] & 0xff)
3325               {
3326                 case 0x00:
3327                     GETBYTE ();
3328                     switch (op[3] & 0x00)
3329                     {
3330                       case 0x00:
3331                         goto op_semantics_7;
3332                         break;
3333                     }
3334                   break;
3335                 case 0x04:
3336                     GETBYTE ();
3337                     switch (op[3] & 0x00)
3338                     {
3339                       case 0x00:
3340                         goto op_semantics_8;
3341                         break;
3342                     }
3343                   break;
3344                 case 0x05:
3345                     GETBYTE ();
3346                     switch (op[3] & 0x00)
3347                     {
3348                       case 0x00:
3349                         goto op_semantics_9;
3350                         break;
3351                     }
3352                   break;
3353                 case 0x06:
3354                     GETBYTE ();
3355                     switch (op[3] & 0x00)
3356                     {
3357                       case 0x00:
3358                         goto op_semantics_10;
3359                         break;
3360                     }
3361                   break;
3362                 case 0x07:
3363                     GETBYTE ();
3364                     switch (op[3] & 0x00)
3365                     {
3366                       case 0x00:
3367                         goto op_semantics_11;
3368                         break;
3369                     }
3370                   break;
3371                 case 0x08:
3372                     GETBYTE ();
3373                     switch (op[3] & 0x00)
3374                     {
3375                       case 0x00:
3376                         goto op_semantics_12;
3377                         break;
3378                     }
3379                   break;
3380                 case 0x09:
3381                     GETBYTE ();
3382                     switch (op[3] & 0x00)
3383                     {
3384                       case 0x00:
3385                         goto op_semantics_13;
3386                         break;
3387                     }
3388                   break;
3389                 case 0x0c:
3390                     GETBYTE ();
3391                     switch (op[3] & 0x00)
3392                     {
3393                       case 0x00:
3394                         goto op_semantics_14;
3395                         break;
3396                     }
3397                   break;
3398                 case 0x0d:
3399                     GETBYTE ();
3400                     switch (op[3] & 0x00)
3401                     {
3402                       case 0x00:
3403                         goto op_semantics_15;
3404                         break;
3405                     }
3406                   break;
3407                 case 0x10:
3408                     GETBYTE ();
3409                     switch (op[3] & 0x00)
3410                     {
3411                       case 0x00:
3412                         goto op_semantics_16;
3413                         break;
3414                     }
3415                   break;
3416                 case 0x11:
3417                     GETBYTE ();
3418                     switch (op[3] & 0x00)
3419                     {
3420                       case 0x00:
3421                         goto op_semantics_17;
3422                         break;
3423                     }
3424                   break;
3425                 case 0x15:
3426                     GETBYTE ();
3427                     switch (op[3] & 0x00)
3428                     {
3429                       case 0x00:
3430                         goto op_semantics_18;
3431                         break;
3432                     }
3433                   break;
3434                 default: UNSUPPORTED(); break;
3435               }
3436             break;
3437           case 0xe2:
3438               GETBYTE ();
3439               switch (op[2] & 0xff)
3440               {
3441                 case 0x00:
3442                     GETBYTE ();
3443                     switch (op[3] & 0x00)
3444                     {
3445                       case 0x00:
3446                         goto op_semantics_7;
3447                         break;
3448                     }
3449                   break;
3450                 case 0x04:
3451                     GETBYTE ();
3452                     switch (op[3] & 0x00)
3453                     {
3454                       case 0x00:
3455                         goto op_semantics_8;
3456                         break;
3457                     }
3458                   break;
3459                 case 0x05:
3460                     GETBYTE ();
3461                     switch (op[3] & 0x00)
3462                     {
3463                       case 0x00:
3464                         goto op_semantics_9;
3465                         break;
3466                     }
3467                   break;
3468                 case 0x06:
3469                     GETBYTE ();
3470                     switch (op[3] & 0x00)
3471                     {
3472                       case 0x00:
3473                         goto op_semantics_10;
3474                         break;
3475                     }
3476                   break;
3477                 case 0x07:
3478                     GETBYTE ();
3479                     switch (op[3] & 0x00)
3480                     {
3481                       case 0x00:
3482                         goto op_semantics_11;
3483                         break;
3484                     }
3485                   break;
3486                 case 0x08:
3487                     GETBYTE ();
3488                     switch (op[3] & 0x00)
3489                     {
3490                       case 0x00:
3491                         goto op_semantics_12;
3492                         break;
3493                     }
3494                   break;
3495                 case 0x09:
3496                     GETBYTE ();
3497                     switch (op[3] & 0x00)
3498                     {
3499                       case 0x00:
3500                         goto op_semantics_13;
3501                         break;
3502                     }
3503                   break;
3504                 case 0x0c:
3505                     GETBYTE ();
3506                     switch (op[3] & 0x00)
3507                     {
3508                       case 0x00:
3509                         goto op_semantics_14;
3510                         break;
3511                     }
3512                   break;
3513                 case 0x0d:
3514                     GETBYTE ();
3515                     switch (op[3] & 0x00)
3516                     {
3517                       case 0x00:
3518                         goto op_semantics_15;
3519                         break;
3520                     }
3521                   break;
3522                 case 0x10:
3523                     GETBYTE ();
3524                     switch (op[3] & 0x00)
3525                     {
3526                       case 0x00:
3527                         goto op_semantics_16;
3528                         break;
3529                     }
3530                   break;
3531                 case 0x11:
3532                     GETBYTE ();
3533                     switch (op[3] & 0x00)
3534                     {
3535                       case 0x00:
3536                         goto op_semantics_17;
3537                         break;
3538                     }
3539                   break;
3540                 case 0x15:
3541                     GETBYTE ();
3542                     switch (op[3] & 0x00)
3543                     {
3544                       case 0x00:
3545                         goto op_semantics_18;
3546                         break;
3547                     }
3548                   break;
3549                 default: UNSUPPORTED(); break;
3550               }
3551             break;
3552           case 0xe3:
3553               GETBYTE ();
3554               switch (op[2] & 0xff)
3555               {
3556                 case 0x00:
3557                     GETBYTE ();
3558                     switch (op[3] & 0x00)
3559                     {
3560                       case 0x00:
3561                         goto op_semantics_7;
3562                         break;
3563                     }
3564                   break;
3565                 case 0x04:
3566                     GETBYTE ();
3567                     switch (op[3] & 0x00)
3568                     {
3569                       case 0x00:
3570                         goto op_semantics_8;
3571                         break;
3572                     }
3573                   break;
3574                 case 0x05:
3575                     GETBYTE ();
3576                     switch (op[3] & 0x00)
3577                     {
3578                       case 0x00:
3579                         goto op_semantics_9;
3580                         break;
3581                     }
3582                   break;
3583                 case 0x06:
3584                     GETBYTE ();
3585                     switch (op[3] & 0x00)
3586                     {
3587                       case 0x00:
3588                         goto op_semantics_10;
3589                         break;
3590                     }
3591                   break;
3592                 case 0x07:
3593                     GETBYTE ();
3594                     switch (op[3] & 0x00)
3595                     {
3596                       case 0x00:
3597                         goto op_semantics_11;
3598                         break;
3599                     }
3600                   break;
3601                 case 0x08:
3602                     GETBYTE ();
3603                     switch (op[3] & 0x00)
3604                     {
3605                       case 0x00:
3606                         goto op_semantics_12;
3607                         break;
3608                     }
3609                   break;
3610                 case 0x09:
3611                     GETBYTE ();
3612                     switch (op[3] & 0x00)
3613                     {
3614                       case 0x00:
3615                         goto op_semantics_13;
3616                         break;
3617                     }
3618                   break;
3619                 case 0x0c:
3620                     GETBYTE ();
3621                     switch (op[3] & 0x00)
3622                     {
3623                       case 0x00:
3624                         goto op_semantics_14;
3625                         break;
3626                     }
3627                   break;
3628                 case 0x0d:
3629                     GETBYTE ();
3630                     switch (op[3] & 0x00)
3631                     {
3632                       case 0x00:
3633                         goto op_semantics_15;
3634                         break;
3635                     }
3636                   break;
3637                 case 0x10:
3638                     GETBYTE ();
3639                     switch (op[3] & 0x00)
3640                     {
3641                       case 0x00:
3642                         goto op_semantics_16;
3643                         break;
3644                     }
3645                   break;
3646                 case 0x11:
3647                     GETBYTE ();
3648                     switch (op[3] & 0x00)
3649                     {
3650                       case 0x00:
3651                         goto op_semantics_17;
3652                         break;
3653                     }
3654                   break;
3655                 case 0x15:
3656                     GETBYTE ();
3657                     switch (op[3] & 0x00)
3658                     {
3659                       case 0x00:
3660                         goto op_semantics_18;
3661                         break;
3662                     }
3663                   break;
3664                 default: UNSUPPORTED(); break;
3665               }
3666             break;
3667           default: UNSUPPORTED(); break;
3668         }
3669       break;
3670     case 0x08:
3671     case 0x09:
3672     case 0x0a:
3673     case 0x0b:
3674     case 0x0c:
3675     case 0x0d:
3676     case 0x0e:
3677     case 0x0f:
3678         {
3679           /** 0000 1dsp                 bra.s   %a0 */
3680 #line 800 "rx-decode.opc"
3681           int dsp AU = op[0] & 0x07;
3682           if (trace)
3683             {
3684               printf ("\033[33m%s\033[0m  %02x\n",
3685                      "/** 0000 1dsp                     bra.s   %a0 */",
3686                      op[0]);
3687               printf ("  dsp = 0x%x\n", dsp);
3688             }
3689           SYNTAX("bra.s %a0");
3690 #line 800 "rx-decode.opc"
3691           ID(branch); DC(pc + dsp3map[dsp]);
3692
3693         }
3694       break;
3695     case 0x10:
3696     case 0x11:
3697     case 0x12:
3698     case 0x13:
3699     case 0x14:
3700     case 0x15:
3701     case 0x16:
3702     case 0x17:
3703     case 0x18:
3704     case 0x19:
3705     case 0x1a:
3706     case 0x1b:
3707     case 0x1c:
3708     case 0x1d:
3709     case 0x1e:
3710     case 0x1f:
3711         {
3712           /** 0001 n dsp                        b%1.s   %a0 */
3713 #line 790 "rx-decode.opc"
3714           int n AU = (op[0] >> 3) & 0x01;
3715 #line 790 "rx-decode.opc"
3716           int dsp AU = op[0] & 0x07;
3717           if (trace)
3718             {
3719               printf ("\033[33m%s\033[0m  %02x\n",
3720                      "/** 0001 n dsp                    b%1.s   %a0 */",
3721                      op[0]);
3722               printf ("  n = 0x%x,", n);
3723               printf ("  dsp = 0x%x\n", dsp);
3724             }
3725           SYNTAX("b%1.s %a0");
3726 #line 790 "rx-decode.opc"
3727           ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3728
3729         }
3730       break;
3731     case 0x20:
3732     case 0x21:
3733     case 0x22:
3734     case 0x23:
3735     case 0x24:
3736     case 0x25:
3737     case 0x26:
3738     case 0x27:
3739     case 0x28:
3740     case 0x29:
3741     case 0x2a:
3742     case 0x2b:
3743     case 0x2c:
3744     case 0x2d:
3745     case 0x2f:
3746         {
3747           /** 0010 cond                 b%1.b   %a0 */
3748 #line 793 "rx-decode.opc"
3749           int cond AU = op[0] & 0x0f;
3750           if (trace)
3751             {
3752               printf ("\033[33m%s\033[0m  %02x\n",
3753                      "/** 0010 cond                     b%1.b   %a0 */",
3754                      op[0]);
3755               printf ("  cond = 0x%x\n", cond);
3756             }
3757           SYNTAX("b%1.b %a0");
3758 #line 793 "rx-decode.opc"
3759           ID(branch); Scc(cond); DC(pc + IMMex (1));
3760
3761         }
3762       break;
3763     case 0x2e:
3764         {
3765           /** 0010 1110                 bra.b   %a0 */
3766           if (trace)
3767             {
3768               printf ("\033[33m%s\033[0m  %02x\n",
3769                      "/** 0010 1110                     bra.b   %a0 */",
3770                      op[0]);
3771             }
3772           SYNTAX("bra.b %a0");
3773 #line 803 "rx-decode.opc"
3774           ID(branch); DC(pc + IMMex(1));
3775
3776         }
3777       break;
3778     case 0x38:
3779         {
3780           /** 0011 1000                 bra.w   %a0 */
3781           if (trace)
3782             {
3783               printf ("\033[33m%s\033[0m  %02x\n",
3784                      "/** 0011 1000                     bra.w   %a0 */",
3785                      op[0]);
3786             }
3787           SYNTAX("bra.w %a0");
3788 #line 806 "rx-decode.opc"
3789           ID(branch); DC(pc + IMMex(2));
3790
3791         }
3792       break;
3793     case 0x39:
3794         {
3795           /** 0011 1001                 bsr.w   %a0 */
3796           if (trace)
3797             {
3798               printf ("\033[33m%s\033[0m  %02x\n",
3799                      "/** 0011 1001                     bsr.w   %a0 */",
3800                      op[0]);
3801             }
3802           SYNTAX("bsr.w %a0");
3803 #line 822 "rx-decode.opc"
3804           ID(jsr); DC(pc + IMMex(2));
3805
3806         }
3807       break;
3808     case 0x3a:
3809     case 0x3b:
3810         {
3811           /** 0011 101c                 b%1.w   %a0 */
3812 #line 796 "rx-decode.opc"
3813           int c AU = op[0] & 0x01;
3814           if (trace)
3815             {
3816               printf ("\033[33m%s\033[0m  %02x\n",
3817                      "/** 0011 101c                     b%1.w   %a0 */",
3818                      op[0]);
3819               printf ("  c = 0x%x\n", c);
3820             }
3821           SYNTAX("b%1.w %a0");
3822 #line 796 "rx-decode.opc"
3823           ID(branch); Scc(c); DC(pc + IMMex (2));
3824
3825
3826         }
3827       break;
3828     case 0x3c:
3829         GETBYTE ();
3830         switch (op[1] & 0x00)
3831         {
3832           case 0x00:
3833             op_semantics_20:
3834               {
3835                 /** 0011 11sz d dst sppp                mov%s   #%1, %0 */
3836 #line 332 "rx-decode.opc"
3837                 int sz AU = op[0] & 0x03;
3838 #line 332 "rx-decode.opc"
3839                 int d AU = (op[1] >> 7) & 0x01;
3840 #line 332 "rx-decode.opc"
3841                 int dst AU = (op[1] >> 4) & 0x07;
3842 #line 332 "rx-decode.opc"
3843                 int sppp AU = op[1] & 0x0f;
3844                 if (trace)
3845                   {
3846                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3847                            "/** 0011 11sz d dst sppp            mov%s   #%1, %0 */",
3848                            op[0], op[1]);
3849                     printf ("  sz = 0x%x,", sz);
3850                     printf ("  d = 0x%x,", d);
3851                     printf ("  dst = 0x%x,", dst);
3852                     printf ("  sppp = 0x%x\n", sppp);
3853                   }
3854                 SYNTAX("mov%s   #%1, %0");
3855 #line 332 "rx-decode.opc"
3856                 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3857
3858               }
3859             break;
3860         }
3861       break;
3862     case 0x3d:
3863         GETBYTE ();
3864         switch (op[1] & 0x00)
3865         {
3866           case 0x00:
3867             goto op_semantics_20;
3868             break;
3869         }
3870       break;
3871     case 0x3e:
3872         GETBYTE ();
3873         switch (op[1] & 0x00)
3874         {
3875           case 0x00:
3876             goto op_semantics_20;
3877             break;
3878         }
3879       break;
3880     case 0x3f:
3881         GETBYTE ();
3882         switch (op[1] & 0x00)
3883         {
3884           case 0x00:
3885               {
3886                 /** 0011 1111 rega regb         rtsd    #%1, %2-%0 */
3887 #line 429 "rx-decode.opc"
3888                 int rega AU = (op[1] >> 4) & 0x0f;
3889 #line 429 "rx-decode.opc"
3890                 int regb AU = op[1] & 0x0f;
3891                 if (trace)
3892                   {
3893                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3894                            "/** 0011 1111 rega regb             rtsd    #%1, %2-%0 */",
3895                            op[0], op[1]);
3896                     printf ("  rega = 0x%x,", rega);
3897                     printf ("  regb = 0x%x\n", regb);
3898                   }
3899                 SYNTAX("rtsd    #%1, %2-%0");
3900 #line 429 "rx-decode.opc"
3901                 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3902
3903               /*----------------------------------------------------------------------*/
3904               /* AND                                                                    */
3905
3906               }
3907             break;
3908         }
3909       break;
3910     case 0x40:
3911         GETBYTE ();
3912         switch (op[1] & 0x00)
3913         {
3914           case 0x00:
3915             op_semantics_21:
3916               {
3917                 /** 0100 00ss rsrc rdst                 sub     %2%S2, %1 */
3918 #line 564 "rx-decode.opc"
3919                 int ss AU = op[0] & 0x03;
3920 #line 564 "rx-decode.opc"
3921                 int rsrc AU = (op[1] >> 4) & 0x0f;
3922 #line 564 "rx-decode.opc"
3923                 int rdst AU = op[1] & 0x0f;
3924                 if (trace)
3925                   {
3926                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3927                            "/** 0100 00ss rsrc rdst                     sub     %2%S2, %1 */",
3928                            op[0], op[1]);
3929                     printf ("  ss = 0x%x,", ss);
3930                     printf ("  rsrc = 0x%x,", rsrc);
3931                     printf ("  rdst = 0x%x\n", rdst);
3932                   }
3933                 SYNTAX("sub     %2%S2, %1");
3934 #line 564 "rx-decode.opc"
3935                 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3936
3937               }
3938             break;
3939         }
3940       break;
3941     case 0x41:
3942         GETBYTE ();
3943         switch (op[1] & 0x00)
3944         {
3945           case 0x00:
3946             goto op_semantics_21;
3947             break;
3948         }
3949       break;
3950     case 0x42:
3951         GETBYTE ();
3952         switch (op[1] & 0x00)
3953         {
3954           case 0x00:
3955             goto op_semantics_21;
3956             break;
3957         }
3958       break;
3959     case 0x43:
3960         GETBYTE ();
3961         switch (op[1] & 0x00)
3962         {
3963           case 0x00:
3964             goto op_semantics_21;
3965             break;
3966         }
3967       break;
3968     case 0x44:
3969         GETBYTE ();
3970         switch (op[1] & 0x00)
3971         {
3972           case 0x00:
3973             op_semantics_22:
3974               {
3975                 /** 0100 01ss rsrc rdst         cmp     %2%S2, %1 */
3976 #line 552 "rx-decode.opc"
3977                 int ss AU = op[0] & 0x03;
3978 #line 552 "rx-decode.opc"
3979                 int rsrc AU = (op[1] >> 4) & 0x0f;
3980 #line 552 "rx-decode.opc"
3981                 int rdst AU = op[1] & 0x0f;
3982                 if (trace)
3983                   {
3984                     printf ("\033[33m%s\033[0m  %02x %02x\n",
3985                            "/** 0100 01ss rsrc rdst             cmp     %2%S2, %1 */",
3986                            op[0], op[1]);
3987                     printf ("  ss = 0x%x,", ss);
3988                     printf ("  rsrc = 0x%x,", rsrc);
3989                     printf ("  rdst = 0x%x\n", rdst);
3990                   }
3991                 SYNTAX("cmp     %2%S2, %1");
3992 #line 552 "rx-decode.opc"
3993                 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3994
3995               }
3996             break;
3997         }
3998       break;
3999     case 0x45:
4000         GETBYTE ();
4001         switch (op[1] & 0x00)
4002         {
4003           case 0x00:
4004             goto op_semantics_22;
4005             break;
4006         }
4007       break;
4008     case 0x46:
4009         GETBYTE ();
4010         switch (op[1] & 0x00)
4011         {
4012           case 0x00:
4013             goto op_semantics_22;
4014             break;
4015         }
4016       break;
4017     case 0x47:
4018         GETBYTE ();
4019         switch (op[1] & 0x00)
4020         {
4021           case 0x00:
4022             goto op_semantics_22;
4023             break;
4024         }
4025       break;
4026     case 0x48:
4027         GETBYTE ();
4028         switch (op[1] & 0x00)
4029         {
4030           case 0x00:
4031             op_semantics_23:
4032               {
4033                 /** 0100 10ss rsrc rdst                 add     %1%S1, %0 */
4034 #line 528 "rx-decode.opc"
4035                 int ss AU = op[0] & 0x03;
4036 #line 528 "rx-decode.opc"
4037                 int rsrc AU = (op[1] >> 4) & 0x0f;
4038 #line 528 "rx-decode.opc"
4039                 int rdst AU = op[1] & 0x0f;
4040                 if (trace)
4041                   {
4042                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4043                            "/** 0100 10ss rsrc rdst                     add     %1%S1, %0 */",
4044                            op[0], op[1]);
4045                     printf ("  ss = 0x%x,", ss);
4046                     printf ("  rsrc = 0x%x,", rsrc);
4047                     printf ("  rdst = 0x%x\n", rdst);
4048                   }
4049                 SYNTAX("add     %1%S1, %0");
4050 #line 528 "rx-decode.opc"
4051                 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
4052
4053               }
4054             break;
4055         }
4056       break;
4057     case 0x49:
4058         GETBYTE ();
4059         switch (op[1] & 0x00)
4060         {
4061           case 0x00:
4062             goto op_semantics_23;
4063             break;
4064         }
4065       break;
4066     case 0x4a:
4067         GETBYTE ();
4068         switch (op[1] & 0x00)
4069         {
4070           case 0x00:
4071             goto op_semantics_23;
4072             break;
4073         }
4074       break;
4075     case 0x4b:
4076         GETBYTE ();
4077         switch (op[1] & 0x00)
4078         {
4079           case 0x00:
4080             goto op_semantics_23;
4081             break;
4082         }
4083       break;
4084     case 0x4c:
4085         GETBYTE ();
4086         switch (op[1] & 0x00)
4087         {
4088           case 0x00:
4089             op_semantics_24:
4090               {
4091                 /** 0100 11ss rsrc rdst                 mul     %1%S1, %0 */
4092 #line 671 "rx-decode.opc"
4093                 int ss AU = op[0] & 0x03;
4094 #line 671 "rx-decode.opc"
4095                 int rsrc AU = (op[1] >> 4) & 0x0f;
4096 #line 671 "rx-decode.opc"
4097                 int rdst AU = op[1] & 0x0f;
4098                 if (trace)
4099                   {
4100                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4101                            "/** 0100 11ss rsrc rdst                     mul     %1%S1, %0 */",
4102                            op[0], op[1]);
4103                     printf ("  ss = 0x%x,", ss);
4104                     printf ("  rsrc = 0x%x,", rsrc);
4105                     printf ("  rdst = 0x%x\n", rdst);
4106                   }
4107                 SYNTAX("mul     %1%S1, %0");
4108 #line 671 "rx-decode.opc"
4109                 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
4110
4111               }
4112             break;
4113         }
4114       break;
4115     case 0x4d:
4116         GETBYTE ();
4117         switch (op[1] & 0x00)
4118         {
4119           case 0x00:
4120             goto op_semantics_24;
4121             break;
4122         }
4123       break;
4124     case 0x4e:
4125         GETBYTE ();
4126         switch (op[1] & 0x00)
4127         {
4128           case 0x00:
4129             goto op_semantics_24;
4130             break;
4131         }
4132       break;
4133     case 0x4f:
4134         GETBYTE ();
4135         switch (op[1] & 0x00)
4136         {
4137           case 0x00:
4138             goto op_semantics_24;
4139             break;
4140         }
4141       break;
4142     case 0x50:
4143         GETBYTE ();
4144         switch (op[1] & 0x00)
4145         {
4146           case 0x00:
4147             op_semantics_25:
4148               {
4149                 /** 0101 00ss rsrc rdst                 and     %1%S1, %0 */
4150 #line 441 "rx-decode.opc"
4151                 int ss AU = op[0] & 0x03;
4152 #line 441 "rx-decode.opc"
4153                 int rsrc AU = (op[1] >> 4) & 0x0f;
4154 #line 441 "rx-decode.opc"
4155                 int rdst AU = op[1] & 0x0f;
4156                 if (trace)
4157                   {
4158                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4159                            "/** 0101 00ss rsrc rdst                     and     %1%S1, %0 */",
4160                            op[0], op[1]);
4161                     printf ("  ss = 0x%x,", ss);
4162                     printf ("  rsrc = 0x%x,", rsrc);
4163                     printf ("  rdst = 0x%x\n", rdst);
4164                   }
4165                 SYNTAX("and     %1%S1, %0");
4166 #line 441 "rx-decode.opc"
4167                 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
4168
4169               }
4170             break;
4171         }
4172       break;
4173     case 0x51:
4174         GETBYTE ();
4175         switch (op[1] & 0x00)
4176         {
4177           case 0x00:
4178             goto op_semantics_25;
4179             break;
4180         }
4181       break;
4182     case 0x52:
4183         GETBYTE ();
4184         switch (op[1] & 0x00)
4185         {
4186           case 0x00:
4187             goto op_semantics_25;
4188             break;
4189         }
4190       break;
4191     case 0x53:
4192         GETBYTE ();
4193         switch (op[1] & 0x00)
4194         {
4195           case 0x00:
4196             goto op_semantics_25;
4197             break;
4198         }
4199       break;
4200     case 0x54:
4201         GETBYTE ();
4202         switch (op[1] & 0x00)
4203         {
4204           case 0x00:
4205             op_semantics_26:
4206               {
4207                 /** 0101 01ss rsrc rdst                 or      %1%S1, %0 */
4208 #line 459 "rx-decode.opc"
4209                 int ss AU = op[0] & 0x03;
4210 #line 459 "rx-decode.opc"
4211                 int rsrc AU = (op[1] >> 4) & 0x0f;
4212 #line 459 "rx-decode.opc"
4213                 int rdst AU = op[1] & 0x0f;
4214                 if (trace)
4215                   {
4216                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4217                            "/** 0101 01ss rsrc rdst                     or      %1%S1, %0 */",
4218                            op[0], op[1]);
4219                     printf ("  ss = 0x%x,", ss);
4220                     printf ("  rsrc = 0x%x,", rsrc);
4221                     printf ("  rdst = 0x%x\n", rdst);
4222                   }
4223                 SYNTAX("or      %1%S1, %0");
4224 #line 459 "rx-decode.opc"
4225                 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4226
4227               }
4228             break;
4229         }
4230       break;
4231     case 0x55:
4232         GETBYTE ();
4233         switch (op[1] & 0x00)
4234         {
4235           case 0x00:
4236             goto op_semantics_26;
4237             break;
4238         }
4239       break;
4240     case 0x56:
4241         GETBYTE ();
4242         switch (op[1] & 0x00)
4243         {
4244           case 0x00:
4245             goto op_semantics_26;
4246             break;
4247         }
4248       break;
4249     case 0x57:
4250         GETBYTE ();
4251         switch (op[1] & 0x00)
4252         {
4253           case 0x00:
4254             goto op_semantics_26;
4255             break;
4256         }
4257       break;
4258     case 0x58:
4259         GETBYTE ();
4260         switch (op[1] & 0x00)
4261         {
4262           case 0x00:
4263             op_semantics_27:
4264               {
4265                 /** 0101 1 s ss rsrc rdst       movu%s  %1, %0 */
4266 #line 380 "rx-decode.opc"
4267                 int s AU = (op[0] >> 2) & 0x01;
4268 #line 380 "rx-decode.opc"
4269                 int ss AU = op[0] & 0x03;
4270 #line 380 "rx-decode.opc"
4271                 int rsrc AU = (op[1] >> 4) & 0x0f;
4272 #line 380 "rx-decode.opc"
4273                 int rdst AU = op[1] & 0x0f;
4274                 if (trace)
4275                   {
4276                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4277                            "/** 0101 1 s ss rsrc rdst   movu%s  %1, %0 */",
4278                            op[0], op[1]);
4279                     printf ("  s = 0x%x,", s);
4280                     printf ("  ss = 0x%x,", ss);
4281                     printf ("  rsrc = 0x%x,", rsrc);
4282                     printf ("  rdst = 0x%x\n", rdst);
4283                   }
4284                 SYNTAX("movu%s  %1, %0");
4285 #line 380 "rx-decode.opc"
4286                 ID(mov); uBW(s); SD(ss, rsrc, s); DR(rdst); F_____;
4287
4288               }
4289             break;
4290         }
4291       break;
4292     case 0x59:
4293         GETBYTE ();
4294         switch (op[1] & 0x00)
4295         {
4296           case 0x00:
4297             goto op_semantics_27;
4298             break;
4299         }
4300       break;
4301     case 0x5a:
4302         GETBYTE ();
4303         switch (op[1] & 0x00)
4304         {
4305           case 0x00:
4306             goto op_semantics_27;
4307             break;
4308         }
4309       break;
4310     case 0x5b:
4311         GETBYTE ();
4312         switch (op[1] & 0x00)
4313         {
4314           case 0x00:
4315             goto op_semantics_27;
4316             break;
4317         }
4318       break;
4319     case 0x5c:
4320         GETBYTE ();
4321         switch (op[1] & 0x00)
4322         {
4323           case 0x00:
4324             goto op_semantics_27;
4325             break;
4326         }
4327       break;
4328     case 0x5d:
4329         GETBYTE ();
4330         switch (op[1] & 0x00)
4331         {
4332           case 0x00:
4333             goto op_semantics_27;
4334             break;
4335         }
4336       break;
4337     case 0x5e:
4338         GETBYTE ();
4339         switch (op[1] & 0x00)
4340         {
4341           case 0x00:
4342             goto op_semantics_27;
4343             break;
4344         }
4345       break;
4346     case 0x5f:
4347         GETBYTE ();
4348         switch (op[1] & 0x00)
4349         {
4350           case 0x00:
4351             goto op_semantics_27;
4352             break;
4353         }
4354       break;
4355     case 0x60:
4356         GETBYTE ();
4357         switch (op[1] & 0x00)
4358         {
4359           case 0x00:
4360               {
4361                 /** 0110 0000 immm rdst                 sub     #%2, %0 */
4362 #line 561 "rx-decode.opc"
4363                 int immm AU = (op[1] >> 4) & 0x0f;
4364 #line 561 "rx-decode.opc"
4365                 int rdst AU = op[1] & 0x0f;
4366                 if (trace)
4367                   {
4368                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4369                            "/** 0110 0000 immm rdst                     sub     #%2, %0 */",
4370                            op[0], op[1]);
4371                     printf ("  immm = 0x%x,", immm);
4372                     printf ("  rdst = 0x%x\n", rdst);
4373                   }
4374                 SYNTAX("sub     #%2, %0");
4375 #line 561 "rx-decode.opc"
4376                 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4377
4378               }
4379             break;
4380         }
4381       break;
4382     case 0x61:
4383         GETBYTE ();
4384         switch (op[1] & 0x00)
4385         {
4386           case 0x00:
4387               {
4388                 /** 0110 0001 immm rdst                 cmp     #%2, %1 */
4389 #line 543 "rx-decode.opc"
4390                 int immm AU = (op[1] >> 4) & 0x0f;
4391 #line 543 "rx-decode.opc"
4392                 int rdst AU = op[1] & 0x0f;
4393                 if (trace)
4394                   {
4395                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4396                            "/** 0110 0001 immm rdst                     cmp     #%2, %1 */",
4397                            op[0], op[1]);
4398                     printf ("  immm = 0x%x,", immm);
4399                     printf ("  rdst = 0x%x\n", rdst);
4400                   }
4401                 SYNTAX("cmp     #%2, %1");
4402 #line 543 "rx-decode.opc"
4403                 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4404
4405               }
4406             break;
4407         }
4408       break;
4409     case 0x62:
4410         GETBYTE ();
4411         switch (op[1] & 0x00)
4412         {
4413           case 0x00:
4414               {
4415                 /** 0110 0010 immm rdst                 add     #%1, %0 */
4416 #line 525 "rx-decode.opc"
4417                 int immm AU = (op[1] >> 4) & 0x0f;
4418 #line 525 "rx-decode.opc"
4419                 int rdst AU = op[1] & 0x0f;
4420                 if (trace)
4421                   {
4422                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4423                            "/** 0110 0010 immm rdst                     add     #%1, %0 */",
4424                            op[0], op[1]);
4425                     printf ("  immm = 0x%x,", immm);
4426                     printf ("  rdst = 0x%x\n", rdst);
4427                   }
4428                 SYNTAX("add     #%1, %0");
4429 #line 525 "rx-decode.opc"
4430                 ID(add); SC(immm); DR(rdst); F_OSZC;
4431
4432               }
4433             break;
4434         }
4435       break;
4436     case 0x63:
4437         GETBYTE ();
4438         switch (op[1] & 0x00)
4439         {
4440           case 0x00:
4441               {
4442                 /** 0110 0011 immm rdst                 mul     #%1, %0 */
4443 #line 637 "rx-decode.opc"
4444                 int immm AU = (op[1] >> 4) & 0x0f;
4445 #line 637 "rx-decode.opc"
4446                 int rdst AU = op[1] & 0x0f;
4447                 if (trace)
4448                   {
4449                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4450                            "/** 0110 0011 immm rdst                     mul     #%1, %0 */",
4451                            op[0], op[1]);
4452                     printf ("  immm = 0x%x,", immm);
4453                     printf ("  rdst = 0x%x\n", rdst);
4454                   }
4455                 SYNTAX("mul     #%1, %0");
4456 #line 637 "rx-decode.opc"
4457                 if (immm == 1 && rdst == 0)
4458                   {
4459                     ID(nop2);
4460                     SYNTAX ("nop\t; mul\t#1, r0");
4461                   }
4462                 else
4463                   {
4464                     ID(mul);
4465                   }
4466                 DR(rdst); SC(immm); F_____;
4467
4468               }
4469             break;
4470         }
4471       break;
4472     case 0x64:
4473         GETBYTE ();
4474         switch (op[1] & 0x00)
4475         {
4476           case 0x00:
4477               {
4478                 /** 0110 0100 immm rdst                 and     #%1, %0 */
4479 #line 435 "rx-decode.opc"
4480                 int immm AU = (op[1] >> 4) & 0x0f;
4481 #line 435 "rx-decode.opc"
4482                 int rdst AU = op[1] & 0x0f;
4483                 if (trace)
4484                   {
4485                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4486                            "/** 0110 0100 immm rdst                     and     #%1, %0 */",
4487                            op[0], op[1]);
4488                     printf ("  immm = 0x%x,", immm);
4489                     printf ("  rdst = 0x%x\n", rdst);
4490                   }
4491                 SYNTAX("and     #%1, %0");
4492 #line 435 "rx-decode.opc"
4493                 ID(and); SC(immm); DR(rdst); F__SZ_;
4494
4495               }
4496             break;
4497         }
4498       break;
4499     case 0x65:
4500         GETBYTE ();
4501         switch (op[1] & 0x00)
4502         {
4503           case 0x00:
4504               {
4505                 /** 0110 0101 immm rdst                 or      #%1, %0 */
4506 #line 453 "rx-decode.opc"
4507                 int immm AU = (op[1] >> 4) & 0x0f;
4508 #line 453 "rx-decode.opc"
4509                 int rdst AU = op[1] & 0x0f;
4510                 if (trace)
4511                   {
4512                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4513                            "/** 0110 0101 immm rdst                     or      #%1, %0 */",
4514                            op[0], op[1]);
4515                     printf ("  immm = 0x%x,", immm);
4516                     printf ("  rdst = 0x%x\n", rdst);
4517                   }
4518                 SYNTAX("or      #%1, %0");
4519 #line 453 "rx-decode.opc"
4520                 ID(or); SC(immm); DR(rdst); F__SZ_;
4521
4522               }
4523             break;
4524         }
4525       break;
4526     case 0x66:
4527         GETBYTE ();
4528         switch (op[1] & 0x00)
4529         {
4530           case 0x00:
4531               {
4532                 /** 0110 0110 immm rdst         mov%s   #%1, %0 */
4533 #line 329 "rx-decode.opc"
4534                 int immm AU = (op[1] >> 4) & 0x0f;
4535 #line 329 "rx-decode.opc"
4536                 int rdst AU = op[1] & 0x0f;
4537                 if (trace)
4538                   {
4539                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4540                            "/** 0110 0110 immm rdst             mov%s   #%1, %0 */",
4541                            op[0], op[1]);
4542                     printf ("  immm = 0x%x,", immm);
4543                     printf ("  rdst = 0x%x\n", rdst);
4544                   }
4545                 SYNTAX("mov%s   #%1, %0");
4546 #line 329 "rx-decode.opc"
4547                 ID(mov); DR(rdst); SC(immm); F_____;
4548
4549               }
4550             break;
4551         }
4552       break;
4553     case 0x67:
4554         {
4555           /** 0110 0111                 rtsd    #%1 */
4556           if (trace)
4557             {
4558               printf ("\033[33m%s\033[0m  %02x\n",
4559                      "/** 0110 0111                     rtsd    #%1 */",
4560                      op[0]);
4561             }
4562           SYNTAX("rtsd  #%1");
4563 #line 426 "rx-decode.opc"
4564           ID(rtsd); SC(IMM(1) * 4);
4565
4566         }
4567       break;
4568     case 0x68:
4569         GETBYTE ();
4570         switch (op[1] & 0x00)
4571         {
4572           case 0x00:
4573             op_semantics_28:
4574               {
4575                 /** 0110 100i mmmm rdst                 shlr    #%2, %0 */
4576 #line 751 "rx-decode.opc"
4577                 int i AU = op[0] & 0x01;
4578 #line 751 "rx-decode.opc"
4579                 int mmmm AU = (op[1] >> 4) & 0x0f;
4580 #line 751 "rx-decode.opc"
4581                 int rdst AU = op[1] & 0x0f;
4582                 if (trace)
4583                   {
4584                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4585                            "/** 0110 100i mmmm rdst                     shlr    #%2, %0 */",
4586                            op[0], op[1]);
4587                     printf ("  i = 0x%x,", i);
4588                     printf ("  mmmm = 0x%x,", mmmm);
4589                     printf ("  rdst = 0x%x\n", rdst);
4590                   }
4591                 SYNTAX("shlr    #%2, %0");
4592 #line 751 "rx-decode.opc"
4593                 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4594
4595               }
4596             break;
4597         }
4598       break;
4599     case 0x69:
4600         GETBYTE ();
4601         switch (op[1] & 0x00)
4602         {
4603           case 0x00:
4604             goto op_semantics_28;
4605             break;
4606         }
4607       break;
4608     case 0x6a:
4609         GETBYTE ();
4610         switch (op[1] & 0x00)
4611         {
4612           case 0x00:
4613             op_semantics_29:
4614               {
4615                 /** 0110 101i mmmm rdst                 shar    #%2, %0 */
4616 #line 741 "rx-decode.opc"
4617                 int i AU = op[0] & 0x01;
4618 #line 741 "rx-decode.opc"
4619                 int mmmm AU = (op[1] >> 4) & 0x0f;
4620 #line 741 "rx-decode.opc"
4621                 int rdst AU = op[1] & 0x0f;
4622                 if (trace)
4623                   {
4624                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4625                            "/** 0110 101i mmmm rdst                     shar    #%2, %0 */",
4626                            op[0], op[1]);
4627                     printf ("  i = 0x%x,", i);
4628                     printf ("  mmmm = 0x%x,", mmmm);
4629                     printf ("  rdst = 0x%x\n", rdst);
4630                   }
4631                 SYNTAX("shar    #%2, %0");
4632 #line 741 "rx-decode.opc"
4633                 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4634
4635               }
4636             break;
4637         }
4638       break;
4639     case 0x6b:
4640         GETBYTE ();
4641         switch (op[1] & 0x00)
4642         {
4643           case 0x00:
4644             goto op_semantics_29;
4645             break;
4646         }
4647       break;
4648     case 0x6c:
4649         GETBYTE ();
4650         switch (op[1] & 0x00)
4651         {
4652           case 0x00:
4653             op_semantics_30:
4654               {
4655                 /** 0110 110i mmmm rdst                 shll    #%2, %0 */
4656 #line 731 "rx-decode.opc"
4657                 int i AU = op[0] & 0x01;
4658 #line 731 "rx-decode.opc"
4659                 int mmmm AU = (op[1] >> 4) & 0x0f;
4660 #line 731 "rx-decode.opc"
4661                 int rdst AU = op[1] & 0x0f;
4662                 if (trace)
4663                   {
4664                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4665                            "/** 0110 110i mmmm rdst                     shll    #%2, %0 */",
4666                            op[0], op[1]);
4667                     printf ("  i = 0x%x,", i);
4668                     printf ("  mmmm = 0x%x,", mmmm);
4669                     printf ("  rdst = 0x%x\n", rdst);
4670                   }
4671                 SYNTAX("shll    #%2, %0");
4672 #line 731 "rx-decode.opc"
4673                 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4674
4675               }
4676             break;
4677         }
4678       break;
4679     case 0x6d:
4680         GETBYTE ();
4681         switch (op[1] & 0x00)
4682         {
4683           case 0x00:
4684             goto op_semantics_30;
4685             break;
4686         }
4687       break;
4688     case 0x6e:
4689         GETBYTE ();
4690         switch (op[1] & 0x00)
4691         {
4692           case 0x00:
4693               {
4694                 /** 0110 1110 dsta dstb         pushm   %1-%2 */
4695 #line 393 "rx-decode.opc"
4696                 int dsta AU = (op[1] >> 4) & 0x0f;
4697 #line 393 "rx-decode.opc"
4698                 int dstb AU = op[1] & 0x0f;
4699                 if (trace)
4700                   {
4701                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4702                            "/** 0110 1110 dsta dstb             pushm   %1-%2 */",
4703                            op[0], op[1]);
4704                     printf ("  dsta = 0x%x,", dsta);
4705                     printf ("  dstb = 0x%x\n", dstb);
4706                   }
4707                 SYNTAX("pushm   %1-%2");
4708 #line 393 "rx-decode.opc"
4709                 ID(pushm); SR(dsta); S2R(dstb); F_____;
4710
4711               }
4712             break;
4713         }
4714       break;
4715     case 0x6f:
4716         GETBYTE ();
4717         switch (op[1] & 0x00)
4718         {
4719           case 0x00:
4720               {
4721                 /** 0110 1111 dsta dstb         popm    %1-%2 */
4722 #line 390 "rx-decode.opc"
4723                 int dsta AU = (op[1] >> 4) & 0x0f;
4724 #line 390 "rx-decode.opc"
4725                 int dstb AU = op[1] & 0x0f;
4726                 if (trace)
4727                   {
4728                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4729                            "/** 0110 1111 dsta dstb             popm    %1-%2 */",
4730                            op[0], op[1]);
4731                     printf ("  dsta = 0x%x,", dsta);
4732                     printf ("  dstb = 0x%x\n", dstb);
4733                   }
4734                 SYNTAX("popm    %1-%2");
4735 #line 390 "rx-decode.opc"
4736                 ID(popm); SR(dsta); S2R(dstb); F_____;
4737
4738               }
4739             break;
4740         }
4741       break;
4742     case 0x70:
4743         GETBYTE ();
4744         switch (op[1] & 0x00)
4745         {
4746           case 0x00:
4747             op_semantics_31:
4748               {
4749                 /** 0111 00im rsrc rdst                 add     #%1, %2, %0 */
4750 #line 534 "rx-decode.opc"
4751                 int im AU = op[0] & 0x03;
4752 #line 534 "rx-decode.opc"
4753                 int rsrc AU = (op[1] >> 4) & 0x0f;
4754 #line 534 "rx-decode.opc"
4755                 int rdst AU = op[1] & 0x0f;
4756                 if (trace)
4757                   {
4758                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4759                            "/** 0111 00im rsrc rdst                     add     #%1, %2, %0 */",
4760                            op[0], op[1]);
4761                     printf ("  im = 0x%x,", im);
4762                     printf ("  rsrc = 0x%x,", rsrc);
4763                     printf ("  rdst = 0x%x\n", rdst);
4764                   }
4765                 SYNTAX("add     #%1, %2, %0");
4766 #line 534 "rx-decode.opc"
4767                 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4768
4769               }
4770             break;
4771         }
4772       break;
4773     case 0x71:
4774         GETBYTE ();
4775         switch (op[1] & 0x00)
4776         {
4777           case 0x00:
4778             goto op_semantics_31;
4779             break;
4780         }
4781       break;
4782     case 0x72:
4783         GETBYTE ();
4784         switch (op[1] & 0x00)
4785         {
4786           case 0x00:
4787             goto op_semantics_31;
4788             break;
4789         }
4790       break;
4791     case 0x73:
4792         GETBYTE ();
4793         switch (op[1] & 0x00)
4794         {
4795           case 0x00:
4796             goto op_semantics_31;
4797             break;
4798         }
4799       break;
4800     case 0x74:
4801         GETBYTE ();
4802         switch (op[1] & 0xf0)
4803         {
4804           case 0x00:
4805             op_semantics_32:
4806               {
4807                 /** 0111 01im 0000 rsrc         cmp     #%2, %1%S1 */
4808 #line 546 "rx-decode.opc"
4809                 int im AU = op[0] & 0x03;
4810 #line 546 "rx-decode.opc"
4811                 int rsrc AU = op[1] & 0x0f;
4812                 if (trace)
4813                   {
4814                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4815                            "/** 0111 01im 0000 rsrc             cmp     #%2, %1%S1 */",
4816                            op[0], op[1]);
4817                     printf ("  im = 0x%x,", im);
4818                     printf ("  rsrc = 0x%x\n", rsrc);
4819                   }
4820                 SYNTAX("cmp     #%2, %1%S1");
4821 #line 546 "rx-decode.opc"
4822                 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4823
4824               }
4825             break;
4826           case 0x10:
4827             op_semantics_33:
4828               {
4829                 /** 0111 01im 0001rdst                  mul     #%1, %0 */
4830 #line 649 "rx-decode.opc"
4831                 int im AU = op[0] & 0x03;
4832 #line 649 "rx-decode.opc"
4833                 int rdst AU = op[1] & 0x0f;
4834                 if (trace)
4835                   {
4836                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4837                            "/** 0111 01im 0001rdst                      mul     #%1, %0 */",
4838                            op[0], op[1]);
4839                     printf ("  im = 0x%x,", im);
4840                     printf ("  rdst = 0x%x\n", rdst);
4841                   }
4842                 SYNTAX("mul     #%1, %0");
4843 #line 649 "rx-decode.opc"
4844                 int val = IMMex(im);
4845                 if (val == 1 && rdst == 0)
4846                   {
4847                     SYNTAX("nop\t; mul\t#1, r0");
4848                     switch (im)
4849                 {
4850                 case 2: ID(nop4); break;
4851                 case 3: ID(nop5); break;
4852                 case 0: ID(nop6); break;
4853                 default:
4854                   ID(mul);
4855                   SYNTAX("mul   #%1, %0");
4856                   break;
4857                 }
4858                   }
4859                 else
4860                   {
4861                     ID(mul);
4862                   }
4863                 DR(rdst); SC(val); F_____;
4864
4865               }
4866             break;
4867           case 0x20:
4868             op_semantics_34:
4869               {
4870                 /** 0111 01im 0010 rdst                 and     #%1, %0 */
4871 #line 438 "rx-decode.opc"
4872                 int im AU = op[0] & 0x03;
4873 #line 438 "rx-decode.opc"
4874                 int rdst AU = op[1] & 0x0f;
4875                 if (trace)
4876                   {
4877                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4878                            "/** 0111 01im 0010 rdst                     and     #%1, %0 */",
4879                            op[0], op[1]);
4880                     printf ("  im = 0x%x,", im);
4881                     printf ("  rdst = 0x%x\n", rdst);
4882                   }
4883                 SYNTAX("and     #%1, %0");
4884 #line 438 "rx-decode.opc"
4885                 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4886
4887               }
4888             break;
4889           case 0x30:
4890             op_semantics_35:
4891               {
4892                 /** 0111 01im 0011 rdst                 or      #%1, %0 */
4893 #line 456 "rx-decode.opc"
4894                 int im AU = op[0] & 0x03;
4895 #line 456 "rx-decode.opc"
4896                 int rdst AU = op[1] & 0x0f;
4897                 if (trace)
4898                   {
4899                     printf ("\033[33m%s\033[0m  %02x %02x\n",
4900                            "/** 0111 01im 0011 rdst                     or      #%1, %0 */",
4901                            op[0], op[1]);
4902                     printf ("  im = 0x%x,", im);
4903                     printf ("  rdst = 0x%x\n", rdst);
4904                   }
4905                 SYNTAX("or      #%1, %0");
4906 #line 456 "rx-decode.opc"
4907                 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4908
4909               }
4910             break;
4911           default: UNSUPPORTED(); break;
4912         }
4913       break;
4914     case 0x75:
4915         GETBYTE ();
4916         switch (op[1] & 0xff)
4917         {
4918           case 0x00:
4919           case 0x01:
4920           case 0x02:
4921           case 0x03:
4922           case 0x04:
4923           case 0x05:
4924           case 0x06:
4925           case 0x07:
4926           case 0x08:
4927           case 0x09:
4928           case 0x0a:
4929           case 0x0b:
4930           case 0x0c:
4931           case 0x0d:
4932           case 0x0e:
4933           case 0x0f:
4934             goto op_semantics_32;
4935             break;
4936           case 0x10:
4937           case 0x11:
4938           case 0x12:
4939           case 0x13:
4940           case 0x14:
4941           case 0x15:
4942           case 0x16:
4943           case 0x17:
4944           case 0x18:
4945           case 0x19:
4946           case 0x1a:
4947           case 0x1b:
4948           case 0x1c:
4949           case 0x1d:
4950           case 0x1e:
4951           case 0x1f:
4952             goto op_semantics_33;
4953             break;
4954           case 0x20:
4955           case 0x21:
4956           case 0x22:
4957           case 0x23:
4958           case 0x24:
4959           case 0x25:
4960           case 0x26:
4961           case 0x27:
4962           case 0x28:
4963           case 0x29:
4964           case 0x2a:
4965           case 0x2b:
4966           case 0x2c:
4967           case 0x2d:
4968           case 0x2e:
4969           case 0x2f:
4970             goto op_semantics_34;
4971             break;
4972           case 0x30:
4973           case 0x31:
4974           case 0x32:
4975           case 0x33:
4976           case 0x34:
4977           case 0x35:
4978           case 0x36:
4979           case 0x37:
4980           case 0x38:
4981           case 0x39:
4982           case 0x3a:
4983           case 0x3b:
4984           case 0x3c:
4985           case 0x3d:
4986           case 0x3e:
4987           case 0x3f:
4988             goto op_semantics_35;
4989             break;
4990           case 0x40:
4991           case 0x41:
4992           case 0x42:
4993           case 0x43:
4994           case 0x44:
4995           case 0x45:
4996           case 0x46:
4997           case 0x47:
4998           case 0x48:
4999           case 0x49:
5000           case 0x4a:
5001           case 0x4b:
5002           case 0x4c:
5003           case 0x4d:
5004           case 0x4e:
5005           case 0x4f:
5006               {
5007                 /** 0111 0101 0100 rdst         mov%s   #%1, %0 */
5008 #line 310 "rx-decode.opc"
5009                 int rdst AU = op[1] & 0x0f;
5010                 if (trace)
5011                   {
5012                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5013                            "/** 0111 0101 0100 rdst             mov%s   #%1, %0 */",
5014                            op[0], op[1]);
5015                     printf ("  rdst = 0x%x\n", rdst);
5016                   }
5017                 SYNTAX("mov%s   #%1, %0");
5018 #line 310 "rx-decode.opc"
5019                 ID(mov); DR(rdst); SC(IMM (1)); F_____;
5020
5021               }
5022             break;
5023           case 0x50:
5024           case 0x51:
5025           case 0x52:
5026           case 0x53:
5027           case 0x54:
5028           case 0x55:
5029           case 0x56:
5030           case 0x57:
5031           case 0x58:
5032           case 0x59:
5033           case 0x5a:
5034           case 0x5b:
5035           case 0x5c:
5036           case 0x5d:
5037           case 0x5e:
5038           case 0x5f:
5039               {
5040                 /** 0111 0101 0101 rsrc                 cmp     #%2, %1 */
5041 #line 549 "rx-decode.opc"
5042                 int rsrc AU = op[1] & 0x0f;
5043                 if (trace)
5044                   {
5045                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5046                            "/** 0111 0101 0101 rsrc                     cmp     #%2, %1 */",
5047                            op[0], op[1]);
5048                     printf ("  rsrc = 0x%x\n", rsrc);
5049                   }
5050                 SYNTAX("cmp     #%2, %1");
5051 #line 549 "rx-decode.opc"
5052                 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
5053
5054               }
5055             break;
5056           case 0x60:
5057               {
5058                 /** 0111 0101 0110 0000         int #%1 */
5059                 if (trace)
5060                   {
5061                     printf ("\033[33m%s\033[0m  %02x %02x\n",
5062                            "/** 0111 0101 0110 0000             int #%1 */",
5063                            op[0], op[1]);
5064                   }
5065                 SYNTAX("int #%1");
5066 #line 1056 "rx-decode.opc"
5067                 ID(int); SC(IMM(1));
5068
5069               }
5070             break;
5071           case 0x70:
5072               GETBYTE ();
5073               switch (op[2] & 0xf0)
5074               {
5075                 case 0x00:
5076                     {
5077                       /** 0111 0101 0111 0000 0000 immm mvtipl  #%1 */
5078 #line 1023 "rx-decode.opc"
5079                       int immm AU = op[2] & 0x0f;
5080                       if (trace)
5081                         {
5082                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5083                                  "/** 0111 0101 0111 0000 0000 immm     mvtipl  #%1 */",
5084                                  op[0], op[1], op[2]);
5085                           printf ("  immm = 0x%x\n", immm);
5086                         }
5087                       SYNTAX("mvtipl    #%1");
5088 #line 1023 "rx-decode.opc"
5089                       ID(mvtipl); SC(immm);
5090
5091                     }
5092                   break;
5093                 default: UNSUPPORTED(); break;
5094               }
5095             break;
5096           case 0x90:
5097               GETBYTE ();
5098               switch (op[2] & 0xff)
5099               {
5100                 case 0x1b:
5101                     {
5102                       /** 0111 0101 1001 0000 0001 1011 mvfdr */
5103                       if (trace)
5104                         {
5105                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5106                                  "/** 0111 0101 1001 0000 0001 1011     mvfdr */",
5107                                  op[0], op[1], op[2]);
5108                         }
5109                       SYNTAX("mvfdr");
5110 #line 1229 "rx-decode.opc"
5111                       ID(mvfdr); F_____;
5112
5113                     }
5114                   break;
5115                 default: UNSUPPORTED(); break;
5116               }
5117             break;
5118           case 0xa0:
5119               GETBYTE ();
5120               switch (op[2] & 0x00)
5121               {
5122                 case 0x00:
5123                     {
5124                       /** 0111 0101 1010 0000 rdst rnum dpushm.l        %1-%2 */
5125 #line 1223 "rx-decode.opc"
5126                       int rdst AU = (op[2] >> 4) & 0x0f;
5127 #line 1223 "rx-decode.opc"
5128                       int rnum AU = op[2] & 0x0f;
5129                       if (trace)
5130                         {
5131                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5132                                  "/** 0111 0101 1010 0000 rdst rnum     dpushm.l        %1-%2 */",
5133                                  op[0], op[1], op[2]);
5134                           printf ("  rdst = 0x%x,", rdst);
5135                           printf ("  rnum = 0x%x\n", rnum);
5136                         }
5137                       SYNTAX("dpushm.l  %1-%2");
5138 #line 1223 "rx-decode.opc"
5139                       ID(dpushm); SCR(rdst); S2CR(rdst + rnum); F_____;
5140
5141                     }
5142                   break;
5143               }
5144             break;
5145           case 0xa8:
5146               GETBYTE ();
5147               switch (op[2] & 0x00)
5148               {
5149                 case 0x00:
5150                     {
5151                       /** 0111 0101 1010 1000 rdst rnum dpopm.l %1-%2 */
5152 #line 1217 "rx-decode.opc"
5153                       int rdst AU = (op[2] >> 4) & 0x0f;
5154 #line 1217 "rx-decode.opc"
5155                       int rnum AU = op[2] & 0x0f;
5156                       if (trace)
5157                         {
5158                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5159                                  "/** 0111 0101 1010 1000 rdst rnum     dpopm.l %1-%2 */",
5160                                  op[0], op[1], op[2]);
5161                           printf ("  rdst = 0x%x,", rdst);
5162                           printf ("  rnum = 0x%x\n", rnum);
5163                         }
5164                       SYNTAX("dpopm.l   %1-%2");
5165 #line 1217 "rx-decode.opc"
5166                       ID(dpopm); SCR(rdst); S2CR(rdst + rnum); F_____;
5167
5168                     }
5169                   break;
5170               }
5171             break;
5172           case 0xb0:
5173               GETBYTE ();
5174               switch (op[2] & 0x00)
5175               {
5176                 case 0x00:
5177                     {
5178                       /** 0111 0101 1011 0000 rdst rnum dpushm.d        %1-%2 */
5179 #line 1220 "rx-decode.opc"
5180                       int rdst AU = (op[2] >> 4) & 0x0f;
5181 #line 1220 "rx-decode.opc"
5182                       int rnum AU = op[2] & 0x0f;
5183                       if (trace)
5184                         {
5185                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5186                                  "/** 0111 0101 1011 0000 rdst rnum     dpushm.d        %1-%2 */",
5187                                  op[0], op[1], op[2]);
5188                           printf ("  rdst = 0x%x,", rdst);
5189                           printf ("  rnum = 0x%x\n", rnum);
5190                         }
5191                       SYNTAX("dpushm.d  %1-%2");
5192 #line 1220 "rx-decode.opc"
5193                       ID(dpushm); SDR(rdst); S2DR(rdst + rnum); F_____;
5194
5195                     }
5196                   break;
5197               }
5198             break;
5199           case 0xb8:
5200               GETBYTE ();
5201               switch (op[2] & 0x00)
5202               {
5203                 case 0x00:
5204                     {
5205                       /** 0111 0101 1011 1000 rdst rnum dpopm.d %1-%2 */
5206 #line 1214 "rx-decode.opc"
5207                       int rdst AU = (op[2] >> 4) & 0x0f;
5208 #line 1214 "rx-decode.opc"
5209                       int rnum AU = op[2] & 0x0f;
5210                       if (trace)
5211                         {
5212                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
5213                                  "/** 0111 0101 1011 1000 rdst rnum     dpopm.d %1-%2 */",
5214                                  op[0], op[1], op[2]);
5215                           printf ("  rdst = 0x%x,", rdst);
5216                           printf ("  rnum = 0x%x\n", rnum);
5217                         }
5218                       SYNTAX("dpopm.d   %1-%2");
5219 #line 1214 "rx-decode.opc"
5220                       ID(dpopm); SDR(rdst); S2DR(rdst + rnum); F_____;
5221
5222                     }
5223                   break;
5224               }
5225             break;
5226           default: UNSUPPORTED(); break;
5227         }
5228       break;
5229     case 0x76:
5230         GETBYTE ();
5231         switch (op[1] & 0xff)
5232         {
5233           case 0x00:
5234           case 0x01:
5235           case 0x02:
5236           case 0x03:
5237           case 0x04:
5238           case 0x05:
5239           case 0x06:
5240           case 0x07:
5241           case 0x08:
5242           case 0x09:
5243           case 0x0a:
5244           case 0x0b:
5245           case 0x0c:
5246           case 0x0d:
5247           case 0x0e:
5248           case 0x0f:
5249             goto op_semantics_32;
5250             break;
5251           case 0x10:
5252           case 0x11:
5253           case 0x12:
5254           case 0x13:
5255           case 0x14:
5256           case 0x15:
5257           case 0x16:
5258           case 0x17:
5259           case 0x18:
5260           case 0x19:
5261           case 0x1a:
5262           case 0x1b:
5263           case 0x1c:
5264           case 0x1d:
5265           case 0x1e:
5266           case 0x1f:
5267             goto op_semantics_33;
5268             break;
5269           case 0x20:
5270           case 0x21:
5271           case 0x22:
5272           case 0x23:
5273           case 0x24:
5274           case 0x25:
5275           case 0x26:
5276           case 0x27:
5277           case 0x28:
5278           case 0x29:
5279           case 0x2a:
5280           case 0x2b:
5281           case 0x2c:
5282           case 0x2d:
5283           case 0x2e:
5284           case 0x2f:
5285             goto op_semantics_34;
5286             break;
5287           case 0x30:
5288           case 0x31:
5289           case 0x32:
5290           case 0x33:
5291           case 0x34:
5292           case 0x35:
5293           case 0x36:
5294           case 0x37:
5295           case 0x38:
5296           case 0x39:
5297           case 0x3a:
5298           case 0x3b:
5299           case 0x3c:
5300           case 0x3d:
5301           case 0x3e:
5302           case 0x3f:
5303             goto op_semantics_35;
5304             break;
5305           case 0x90:
5306               GETBYTE ();
5307               switch (op[2] & 0xff)
5308               {
5309                 case 0x00:
5310                     GETBYTE ();
5311                     switch (op[3] & 0x00)
5312                     {
5313                       case 0x00:
5314                         op_semantics_36:
5315                           {
5316                             /** 0111 0110 1001 0000 srcb 0000 rdst srca dadd    %1, %2, %0 */
5317 #line 1238 "rx-decode.opc"
5318                             int srcb AU = (op[2] >> 4) & 0x0f;
5319 #line 1238 "rx-decode.opc"
5320                             int rdst AU = (op[3] >> 4) & 0x0f;
5321 #line 1238 "rx-decode.opc"
5322                             int srca AU = op[3] & 0x0f;
5323                             if (trace)
5324                               {
5325                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5326                                        "/** 0111 0110 1001 0000 srcb 0000 rdst srca     dadd    %1, %2, %0 */",
5327                                        op[0], op[1], op[2], op[3]);
5328                                 printf ("  srcb = 0x%x,", srcb);
5329                                 printf ("  rdst = 0x%x,", rdst);
5330                                 printf ("  srca = 0x%x\n", srca);
5331                               }
5332                             SYNTAX("dadd        %1, %2, %0");
5333 #line 1238 "rx-decode.opc"
5334                             ID(dadd); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5335
5336                           }
5337                         break;
5338                     }
5339                   break;
5340                 case 0x01:
5341                     GETBYTE ();
5342                     switch (op[3] & 0x00)
5343                     {
5344                       case 0x00:
5345                         op_semantics_37:
5346                           {
5347                             /** 0111 0110 1001 0000 srcb 0001 rdst srca dsub    %1, %2, %0 */
5348 #line 1259 "rx-decode.opc"
5349                             int srcb AU = (op[2] >> 4) & 0x0f;
5350 #line 1259 "rx-decode.opc"
5351                             int rdst AU = (op[3] >> 4) & 0x0f;
5352 #line 1259 "rx-decode.opc"
5353                             int srca AU = op[3] & 0x0f;
5354                             if (trace)
5355                               {
5356                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5357                                        "/** 0111 0110 1001 0000 srcb 0001 rdst srca     dsub    %1, %2, %0 */",
5358                                        op[0], op[1], op[2], op[3]);
5359                                 printf ("  srcb = 0x%x,", srcb);
5360                                 printf ("  rdst = 0x%x,", rdst);
5361                                 printf ("  srca = 0x%x\n", srca);
5362                               }
5363                             SYNTAX("dsub        %1, %2, %0");
5364 #line 1259 "rx-decode.opc"
5365                             ID(dsub); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5366
5367                           }
5368                         break;
5369                     }
5370                   break;
5371                 case 0x02:
5372                     GETBYTE ();
5373                     switch (op[3] & 0x00)
5374                     {
5375                       case 0x00:
5376                         op_semantics_38:
5377                           {
5378                             /** 0111 0110 1001 0000 srcb 0010 rdst srca dmul    %1, %2, %0 */
5379 #line 1247 "rx-decode.opc"
5380                             int srcb AU = (op[2] >> 4) & 0x0f;
5381 #line 1247 "rx-decode.opc"
5382                             int rdst AU = (op[3] >> 4) & 0x0f;
5383 #line 1247 "rx-decode.opc"
5384                             int srca AU = op[3] & 0x0f;
5385                             if (trace)
5386                               {
5387                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5388                                        "/** 0111 0110 1001 0000 srcb 0010 rdst srca     dmul    %1, %2, %0 */",
5389                                        op[0], op[1], op[2], op[3]);
5390                                 printf ("  srcb = 0x%x,", srcb);
5391                                 printf ("  rdst = 0x%x,", rdst);
5392                                 printf ("  srca = 0x%x\n", srca);
5393                               }
5394                             SYNTAX("dmul        %1, %2, %0");
5395 #line 1247 "rx-decode.opc"
5396                             ID(dmul); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5397
5398                           }
5399                         break;
5400                     }
5401                   break;
5402                 case 0x05:
5403                     GETBYTE ();
5404                     switch (op[3] & 0x00)
5405                     {
5406                       case 0x00:
5407                         op_semantics_39:
5408                           {
5409                             /** 0111 0110 1001 0000 srcb 0101 rdst srca ddiv    %1, %2, %0 */
5410 #line 1244 "rx-decode.opc"
5411                             int srcb AU = (op[2] >> 4) & 0x0f;
5412 #line 1244 "rx-decode.opc"
5413                             int rdst AU = (op[3] >> 4) & 0x0f;
5414 #line 1244 "rx-decode.opc"
5415                             int srca AU = op[3] & 0x0f;
5416                             if (trace)
5417                               {
5418                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5419                                        "/** 0111 0110 1001 0000 srcb 0101 rdst srca     ddiv    %1, %2, %0 */",
5420                                        op[0], op[1], op[2], op[3]);
5421                                 printf ("  srcb = 0x%x,", srcb);
5422                                 printf ("  rdst = 0x%x,", rdst);
5423                                 printf ("  srca = 0x%x\n", srca);
5424                               }
5425                             SYNTAX("ddiv        %1, %2, %0");
5426 #line 1244 "rx-decode.opc"
5427                             ID(ddiv); DDR(rdst); SDR(srca); S2DR(srcb); F_____;
5428
5429                           }
5430                         break;
5431                     }
5432                   break;
5433                 case 0x08:
5434                     GETBYTE ();
5435                     switch (op[3] & 0x00)
5436                     {
5437                       case 0x00:
5438                         op_semantics_40:
5439                           {
5440                             /** 0111 0110 1001 0000 srcb 1000 cond srca dcmp%0  %1, %2 */
5441 #line 1241 "rx-decode.opc"
5442                             int srcb AU = (op[2] >> 4) & 0x0f;
5443 #line 1241 "rx-decode.opc"
5444                             int cond AU = (op[3] >> 4) & 0x0f;
5445 #line 1241 "rx-decode.opc"
5446                             int srca AU = op[3] & 0x0f;
5447                             if (trace)
5448                               {
5449                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5450                                        "/** 0111 0110 1001 0000 srcb 1000 cond srca     dcmp%0  %1, %2 */",
5451                                        op[0], op[1], op[2], op[3]);
5452                                 printf ("  srcb = 0x%x,", srcb);
5453                                 printf ("  cond = 0x%x,", cond);
5454                                 printf ("  srca = 0x%x\n", srca);
5455                               }
5456                             SYNTAX("dcmp%0      %1, %2");
5457 #line 1241 "rx-decode.opc"
5458                             ID(dcmp); DCND(cond); SDR(srca); S2DR(srcb); F_____;
5459
5460                           }
5461                         break;
5462                     }
5463                   break;
5464                 case 0x0c:
5465                     GETBYTE ();
5466                     switch (op[3] & 0x0f)
5467                     {
5468                       case 0x00:
5469                         op_semantics_41:
5470                           {
5471                             /** 0111 0110 1001 0000 rsrc 1100 rdst 0000 dmov.d  %1, %0 */
5472 #line 1179 "rx-decode.opc"
5473                             int rsrc AU = (op[2] >> 4) & 0x0f;
5474 #line 1179 "rx-decode.opc"
5475                             int rdst AU = (op[3] >> 4) & 0x0f;
5476                             if (trace)
5477                               {
5478                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5479                                        "/** 0111 0110 1001 0000 rsrc 1100 rdst 0000     dmov.d  %1, %0 */",
5480                                        op[0], op[1], op[2], op[3]);
5481                                 printf ("  rsrc = 0x%x,", rsrc);
5482                                 printf ("  rdst = 0x%x\n", rdst);
5483                               }
5484                             SYNTAX("dmov.d      %1, %0");
5485 #line 1179 "rx-decode.opc"
5486                             ID(dmov); DDR(rdst); SDR(rsrc); F_____;
5487
5488                           }
5489                         break;
5490                       case 0x01:
5491                         op_semantics_42:
5492                           {
5493                             /** 0111 0110 1001 0000 rsrc 1100 rdst 0001 dabs    %1, %0 */
5494 #line 1235 "rx-decode.opc"
5495                             int rsrc AU = (op[2] >> 4) & 0x0f;
5496 #line 1235 "rx-decode.opc"
5497                             int rdst AU = (op[3] >> 4) & 0x0f;
5498                             if (trace)
5499                               {
5500                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5501                                        "/** 0111 0110 1001 0000 rsrc 1100 rdst 0001     dabs    %1, %0 */",
5502                                        op[0], op[1], op[2], op[3]);
5503                                 printf ("  rsrc = 0x%x,", rsrc);
5504                                 printf ("  rdst = 0x%x\n", rdst);
5505                               }
5506                             SYNTAX("dabs        %1, %0");
5507 #line 1235 "rx-decode.opc"
5508                             ID(dabs); DDR(rdst); SDR(rsrc); F_____;
5509
5510                           }
5511                         break;
5512                       case 0x02:
5513                         op_semantics_43:
5514                           {
5515                             /** 0111 0110 1001 0000 rsrc 1100 rdst 0010 dneg    %1, %0 */
5516 #line 1250 "rx-decode.opc"
5517                             int rsrc AU = (op[2] >> 4) & 0x0f;
5518 #line 1250 "rx-decode.opc"
5519                             int rdst AU = (op[3] >> 4) & 0x0f;
5520                             if (trace)
5521                               {
5522                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5523                                        "/** 0111 0110 1001 0000 rsrc 1100 rdst 0010     dneg    %1, %0 */",
5524                                        op[0], op[1], op[2], op[3]);
5525                                 printf ("  rsrc = 0x%x,", rsrc);
5526                                 printf ("  rdst = 0x%x\n", rdst);
5527                               }
5528                             SYNTAX("dneg        %1, %0");
5529 #line 1250 "rx-decode.opc"
5530                             ID(dneg); DDR(rdst); SDR(rsrc); F_____;
5531
5532                           }
5533                         break;
5534                       default: UNSUPPORTED(); break;
5535                     }
5536                   break;
5537                 case 0x0d:
5538                     GETBYTE ();
5539                     switch (op[3] & 0x0f)
5540                     {
5541                       case 0x00:
5542                         op_semantics_44:
5543                           {
5544                             /** 0111 0110 1001 0000 rsrc 1101 rdst 0000 dsqrt   %1, %0 */
5545 #line 1256 "rx-decode.opc"
5546                             int rsrc AU = (op[2] >> 4) & 0x0f;
5547 #line 1256 "rx-decode.opc"
5548                             int rdst AU = (op[3] >> 4) & 0x0f;
5549                             if (trace)
5550                               {
5551                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5552                                        "/** 0111 0110 1001 0000 rsrc 1101 rdst 0000     dsqrt   %1, %0 */",
5553                                        op[0], op[1], op[2], op[3]);
5554                                 printf ("  rsrc = 0x%x,", rsrc);
5555                                 printf ("  rdst = 0x%x\n", rdst);
5556                               }
5557                             SYNTAX("dsqrt       %1, %0");
5558 #line 1256 "rx-decode.opc"
5559                             ID(dsqrt); DDR(rdst); SDR(rsrc); F_____;
5560
5561                           }
5562                         break;
5563                       case 0x08:
5564                         op_semantics_45:
5565                           {
5566                             /** 0111 0110 1001 0000 rsrc 1101 rdst 1000 dtoi    %1, %0 */
5567 #line 1265 "rx-decode.opc"
5568                             int rsrc AU = (op[2] >> 4) & 0x0f;
5569 #line 1265 "rx-decode.opc"
5570                             int rdst AU = (op[3] >> 4) & 0x0f;
5571                             if (trace)
5572                               {
5573                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5574                                        "/** 0111 0110 1001 0000 rsrc 1101 rdst 1000     dtoi    %1, %0 */",
5575                                        op[0], op[1], op[2], op[3]);
5576                                 printf ("  rsrc = 0x%x,", rsrc);
5577                                 printf ("  rdst = 0x%x\n", rdst);
5578                               }
5579                             SYNTAX("dtoi        %1, %0");
5580 #line 1265 "rx-decode.opc"
5581                             ID(dtoi); DDR(rdst); SDR(rsrc); F_____;
5582
5583                           }
5584                         break;
5585                       case 0x09:
5586                         op_semantics_46:
5587                           {
5588                             /** 0111 0110 1001 0000 rsrc 1101 rdst 1001 dtou    %1, %0 */
5589 #line 1268 "rx-decode.opc"
5590                             int rsrc AU = (op[2] >> 4) & 0x0f;
5591 #line 1268 "rx-decode.opc"
5592                             int rdst AU = (op[3] >> 4) & 0x0f;
5593                             if (trace)
5594                               {
5595                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5596                                        "/** 0111 0110 1001 0000 rsrc 1101 rdst 1001     dtou    %1, %0 */",
5597                                        op[0], op[1], op[2], op[3]);
5598                                 printf ("  rsrc = 0x%x,", rsrc);
5599                                 printf ("  rdst = 0x%x\n", rdst);
5600                               }
5601                             SYNTAX("dtou        %1, %0");
5602 #line 1268 "rx-decode.opc"
5603                             ID(dtou); DDR(rdst); SDR(rsrc); F_____;
5604
5605                           }
5606                         break;
5607                       case 0x0c:
5608                         op_semantics_47:
5609                           {
5610                             /** 0111 0110 1001 0000 rsrc 1101 rdst 1100 dtof    %1, %0 */
5611 #line 1262 "rx-decode.opc"
5612                             int rsrc AU = (op[2] >> 4) & 0x0f;
5613 #line 1262 "rx-decode.opc"
5614                             int rdst AU = (op[3] >> 4) & 0x0f;
5615                             if (trace)
5616                               {
5617                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5618                                        "/** 0111 0110 1001 0000 rsrc 1101 rdst 1100     dtof    %1, %0 */",
5619                                        op[0], op[1], op[2], op[3]);
5620                                 printf ("  rsrc = 0x%x,", rsrc);
5621                                 printf ("  rdst = 0x%x\n", rdst);
5622                               }
5623                             SYNTAX("dtof        %1, %0");
5624 #line 1262 "rx-decode.opc"
5625                             ID(dtof); DDR(rdst); SDR(rsrc); F_____;
5626
5627                           }
5628                         break;
5629                       case 0x0d:
5630                         op_semantics_48:
5631                           {
5632                             /** 0111 0110 1001 0000 rsrc 1101 rdst 1101 dround  %1, %0 */
5633 #line 1253 "rx-decode.opc"
5634                             int rsrc AU = (op[2] >> 4) & 0x0f;
5635 #line 1253 "rx-decode.opc"
5636                             int rdst AU = (op[3] >> 4) & 0x0f;
5637                             if (trace)
5638                               {
5639                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
5640                                        "/** 0111 0110 1001 0000 rsrc 1101 rdst 1101     dround  %1, %0 */",
5641                                        op[0], op[1], op[2], op[3]);
5642                                 printf ("  rsrc = 0x%x,", rsrc);
5643                                 printf ("  rdst = 0x%x\n", rdst);
5644                               }
5645                             SYNTAX("dround      %1, %0");
5646 #line 1253 "rx-decode.opc"
5647                             ID(dround); DDR(rdst); SDR(rsrc); F_____;
5648
5649                           }
5650                         break;
5651                       default: UNSUPPORTED(); break;
5652                     }
5653                   break;
5654                 case 0x10:
5655                     GETBYTE ();
5656                     switch (op[3] & 0x00)
5657                     {
5658                       case 0x00:
5659                         goto op_semantics_36;
5660                         break;
5661                     }
5662                   break;
5663                 case 0x11:
5664                     GETBYTE ();
5665                     switch (op[3] & 0x00)
5666                     {
5667                       case 0x00:
5668                         goto op_semantics_37;
5669                         break;
5670                     }
5671                   break;
5672                 case 0x12:
5673                     GETBYTE ();
5674                     switch (op[3] & 0x00)
5675                     {
5676                       case 0x00:
5677                         goto op_semantics_38;
5678                         break;
5679                     }
5680                   break;
5681                 case 0x15:
5682                     GETBYTE ();
5683                     switch (op[3] & 0x00)
5684                     {
5685                       case 0x00:
5686                         goto op_semantics_39;
5687                         break;
5688                     }
5689                   break;
5690                 case 0x18:
5691                     GETBYTE ();
5692                     switch (op[3] & 0x00)
5693                     {
5694                       case 0x00:
5695                         goto op_semantics_40;
5696                         break;
5697                     }
5698                   break;
5699                 case 0x1c:
5700                     GETBYTE ();
5701                     switch (op[3] & 0x0f)
5702                     {
5703                       case 0x00:
5704                         goto op_semantics_41;
5705                         break;
5706                       case 0x01:
5707                         goto op_semantics_42;
5708                         break;
5709                       case 0x02:
5710                         goto op_semantics_43;
5711                         break;
5712                       default: UNSUPPORTED(); break;
5713                     }
5714                   break;
5715                 case 0x1d:
5716                     GETBYTE ();
5717                     switch (op[3] & 0x0f)
5718                     {
5719                       case 0x00:
5720                         goto op_semantics_44;
5721                         break;
5722                       case 0x08:
5723                         goto op_semantics_45;
5724                         break;
5725                       case 0x09:
5726                         goto op_semantics_46;
5727                         break;
5728                       case 0x0c:
5729                         goto op_semantics_47;
5730                         break;
5731                       case 0x0d:
5732                         goto op_semantics_48;
5733                         break;
5734                       default: UNSUPPORTED(); break;
5735                     }
5736                   break;
5737                 case 0x20:
5738                     GETBYTE ();
5739                     switch (op[3] & 0x00)
5740                     {
5741                       case 0x00:
5742                         goto op_semantics_36;
5743                         break;
5744                     }
5745                   break;
5746                 case 0x21:
5747                     GETBYTE ();
5748                     switch (op[3] & 0x00)
5749                     {
5750                       case 0x00:
5751                         goto op_semantics_37;
5752                         break;
5753                     }
5754                   break;
5755                 case 0x22:
5756                     GETBYTE ();
5757                     switch (op[3] & 0x00)
5758                     {
5759                       case 0x00:
5760                         goto op_semantics_38;
5761                         break;
5762                     }
5763                   break;
5764                 case 0x25:
5765                     GETBYTE ();
5766                     switch (op[3] & 0x00)
5767                     {
5768                       case 0x00:
5769                         goto op_semantics_39;
5770                         break;
5771                     }
5772                   break;
5773                 case 0x28:
5774                     GETBYTE ();
5775                     switch (op[3] & 0x00)
5776                     {
5777                       case 0x00:
5778                         goto op_semantics_40;
5779                         break;
5780                     }
5781                   break;
5782                 case 0x2c:
5783                     GETBYTE ();
5784                     switch (op[3] & 0x0f)
5785                     {
5786                       case 0x00:
5787                         goto op_semantics_41;
5788                         break;
5789                       case 0x01:
5790                         goto op_semantics_42;
5791                         break;
5792                       case 0x02:
5793                         goto op_semantics_43;
5794                         break;
5795                       default: UNSUPPORTED(); break;
5796                     }
5797                   break;
5798                 case 0x2d:
5799                     GETBYTE ();
5800                     switch (op[3] & 0x0f)
5801                     {
5802                       case 0x00:
5803                         goto op_semantics_44;
5804                         break;
5805                       case 0x08:
5806                         goto op_semantics_45;
5807                         break;
5808                       case 0x09:
5809                         goto op_semantics_46;
5810                         break;
5811                       case 0x0c:
5812                         goto op_semantics_47;
5813                         break;
5814                       case 0x0d:
5815                         goto op_semantics_48;
5816                         break;
5817                       default: UNSUPPORTED(); break;
5818                     }
5819                   break;
5820                 case 0x30:
5821                     GETBYTE ();
5822                     switch (op[3] & 0x00)
5823                     {
5824                       case 0x00:
5825                         goto op_semantics_36;
5826                         break;
5827                     }
5828                   break;
5829                 case 0x31:
5830                     GETBYTE ();
5831                     switch (op[3] & 0x00)
5832                     {
5833                       case 0x00:
5834                         goto op_semantics_37;
5835                         break;
5836                     }
5837                   break;
5838                 case 0x32:
5839                     GETBYTE ();
5840                     switch (op[3] & 0x00)
5841                     {
5842                       case 0x00:
5843                         goto op_semantics_38;
5844                         break;
5845                     }
5846                   break;
5847                 case 0x35:
5848                     GETBYTE ();
5849                     switch (op[3] & 0x00)
5850                     {
5851                       case 0x00:
5852                         goto op_semantics_39;
5853                         break;
5854                     }
5855                   break;
5856                 case 0x38:
5857                     GETBYTE ();
5858                     switch (op[3] & 0x00)
5859                     {
5860                       case 0x00:
5861                         goto op_semantics_40;
5862                         break;
5863                     }
5864                   break;
5865                 case 0x3c:
5866                     GETBYTE ();
5867                     switch (op[3] & 0x0f)
5868                     {
5869                       case 0x00:
5870                         goto op_semantics_41;
5871                         break;
5872                       case 0x01:
5873                         goto op_semantics_42;
5874                         break;
5875                       case 0x02:
5876                         goto op_semantics_43;
5877                         break;
5878                       default: UNSUPPORTED(); break;
5879                     }
5880                   break;
5881                 case 0x3d:
5882                     GETBYTE ();
5883                     switch (op[3] & 0x0f)
5884                     {
5885                       case 0x00:
5886                         goto op_semantics_44;
5887                         break;
5888                       case 0x08:
5889                         goto op_semantics_45;
5890                         break;
5891                       case 0x09:
5892                         goto op_semantics_46;
5893                         break;
5894                       case 0x0c:
5895                         goto op_semantics_47;
5896                         break;
5897                       case 0x0d:
5898                         goto op_semantics_48;
5899                         break;
5900                       default: UNSUPPORTED(); break;
5901                     }
5902                   break;
5903                 case 0x40:
5904                     GETBYTE ();
5905                     switch (op[3] & 0x00)
5906                     {
5907                       case 0x00:
5908                         goto op_semantics_36;
5909                         break;
5910                     }
5911                   break;
5912                 case 0x41:
5913                     GETBYTE ();
5914                     switch (op[3] & 0x00)
5915                     {
5916                       case 0x00:
5917                         goto op_semantics_37;
5918                         break;
5919                     }
5920                   break;
5921                 case 0x42:
5922                     GETBYTE ();
5923                     switch (op[3] & 0x00)
5924                     {
5925                       case 0x00:
5926                         goto op_semantics_38;
5927                         break;
5928                     }
5929                   break;
5930                 case 0x45:
5931                     GETBYTE ();
5932                     switch (op[3] & 0x00)
5933                     {
5934                       case 0x00:
5935                         goto op_semantics_39;
5936                         break;
5937                     }
5938                   break;
5939                 case 0x48:
5940                     GETBYTE ();
5941                     switch (op[3] & 0x00)
5942                     {
5943                       case 0x00:
5944                         goto op_semantics_40;
5945                         break;
5946                     }
5947                   break;
5948                 case 0x4c:
5949                     GETBYTE ();
5950                     switch (op[3] & 0x0f)
5951                     {
5952                       case 0x00:
5953                         goto op_semantics_41;
5954                         break;
5955                       case 0x01:
5956                         goto op_semantics_42;
5957                         break;
5958                       case 0x02:
5959                         goto op_semantics_43;
5960                         break;
5961                       default: UNSUPPORTED(); break;
5962                     }
5963                   break;
5964                 case 0x4d:
5965                     GETBYTE ();
5966                     switch (op[3] & 0x0f)
5967                     {
5968                       case 0x00:
5969                         goto op_semantics_44;
5970                         break;
5971                       case 0x08:
5972                         goto op_semantics_45;
5973                         break;
5974                       case 0x09:
5975                         goto op_semantics_46;
5976                         break;
5977                       case 0x0c:
5978                         goto op_semantics_47;
5979                         break;
5980                       case 0x0d:
5981                         goto op_semantics_48;
5982                         break;
5983                       default: UNSUPPORTED(); break;
5984                     }
5985                   break;
5986                 case 0x50:
5987                     GETBYTE ();
5988                     switch (op[3] & 0x00)
5989                     {
5990                       case 0x00:
5991                         goto op_semantics_36;
5992                         break;
5993                     }
5994                   break;
5995                 case 0x51:
5996                     GETBYTE ();
5997                     switch (op[3] & 0x00)
5998                     {
5999                       case 0x00:
6000                         goto op_semantics_37;
6001                         break;
6002                     }
6003                   break;
6004                 case 0x52:
6005                     GETBYTE ();
6006                     switch (op[3] & 0x00)
6007                     {
6008                       case 0x00:
6009                         goto op_semantics_38;
6010                         break;
6011                     }
6012                   break;
6013                 case 0x55:
6014                     GETBYTE ();
6015                     switch (op[3] & 0x00)
6016                     {
6017                       case 0x00:
6018                         goto op_semantics_39;
6019                         break;
6020                     }
6021                   break;
6022                 case 0x58:
6023                     GETBYTE ();
6024                     switch (op[3] & 0x00)
6025                     {
6026                       case 0x00:
6027                         goto op_semantics_40;
6028                         break;
6029                     }
6030                   break;
6031                 case 0x5c:
6032                     GETBYTE ();
6033                     switch (op[3] & 0x0f)
6034                     {
6035                       case 0x00:
6036                         goto op_semantics_41;
6037                         break;
6038                       case 0x01:
6039                         goto op_semantics_42;
6040                         break;
6041                       case 0x02:
6042                         goto op_semantics_43;
6043                         break;
6044                       default: UNSUPPORTED(); break;
6045                     }
6046                   break;
6047                 case 0x5d:
6048                     GETBYTE ();
6049                     switch (op[3] & 0x0f)
6050                     {
6051                       case 0x00:
6052                         goto op_semantics_44;
6053                         break;
6054                       case 0x08:
6055                         goto op_semantics_45;
6056                         break;
6057                       case 0x09:
6058                         goto op_semantics_46;
6059                         break;
6060                       case 0x0c:
6061                         goto op_semantics_47;
6062                         break;
6063                       case 0x0d:
6064                         goto op_semantics_48;
6065                         break;
6066                       default: UNSUPPORTED(); break;
6067                     }
6068                   break;
6069                 case 0x60:
6070                     GETBYTE ();
6071                     switch (op[3] & 0x00)
6072                     {
6073                       case 0x00:
6074                         goto op_semantics_36;
6075                         break;
6076                     }
6077                   break;
6078                 case 0x61:
6079                     GETBYTE ();
6080                     switch (op[3] & 0x00)
6081                     {
6082                       case 0x00:
6083                         goto op_semantics_37;
6084                         break;
6085                     }
6086                   break;
6087                 case 0x62:
6088                     GETBYTE ();
6089                     switch (op[3] & 0x00)
6090                     {
6091                       case 0x00:
6092                         goto op_semantics_38;
6093                         break;
6094                     }
6095                   break;
6096                 case 0x65:
6097                     GETBYTE ();
6098                     switch (op[3] & 0x00)
6099                     {
6100                       case 0x00:
6101                         goto op_semantics_39;
6102                         break;
6103                     }
6104                   break;
6105                 case 0x68:
6106                     GETBYTE ();
6107                     switch (op[3] & 0x00)
6108                     {
6109                       case 0x00:
6110                         goto op_semantics_40;
6111                         break;
6112                     }
6113                   break;
6114                 case 0x6c:
6115                     GETBYTE ();
6116                     switch (op[3] & 0x0f)
6117                     {
6118                       case 0x00:
6119                         goto op_semantics_41;
6120                         break;
6121                       case 0x01:
6122                         goto op_semantics_42;
6123                         break;
6124                       case 0x02:
6125                         goto op_semantics_43;
6126                         break;
6127                       default: UNSUPPORTED(); break;
6128                     }
6129                   break;
6130                 case 0x6d:
6131                     GETBYTE ();
6132                     switch (op[3] & 0x0f)
6133                     {
6134                       case 0x00:
6135                         goto op_semantics_44;
6136                         break;
6137                       case 0x08:
6138                         goto op_semantics_45;
6139                         break;
6140                       case 0x09:
6141                         goto op_semantics_46;
6142                         break;
6143                       case 0x0c:
6144                         goto op_semantics_47;
6145                         break;
6146                       case 0x0d:
6147                         goto op_semantics_48;
6148                         break;
6149                       default: UNSUPPORTED(); break;
6150                     }
6151                   break;
6152                 case 0x70:
6153                     GETBYTE ();
6154                     switch (op[3] & 0x00)
6155                     {
6156                       case 0x00:
6157                         goto op_semantics_36;
6158                         break;
6159                     }
6160                   break;
6161                 case 0x71:
6162                     GETBYTE ();
6163                     switch (op[3] & 0x00)
6164                     {
6165                       case 0x00:
6166                         goto op_semantics_37;
6167                         break;
6168                     }
6169                   break;
6170                 case 0x72:
6171                     GETBYTE ();
6172                     switch (op[3] & 0x00)
6173                     {
6174                       case 0x00:
6175                         goto op_semantics_38;
6176                         break;
6177                     }
6178                   break;
6179                 case 0x75:
6180                     GETBYTE ();
6181                     switch (op[3] & 0x00)
6182                     {
6183                       case 0x00:
6184                         goto op_semantics_39;
6185                         break;
6186                     }
6187                   break;
6188                 case 0x78:
6189                     GETBYTE ();
6190                     switch (op[3] & 0x00)
6191                     {
6192                       case 0x00:
6193                         goto op_semantics_40;
6194                         break;
6195                     }
6196                   break;
6197                 case 0x7c:
6198                     GETBYTE ();
6199                     switch (op[3] & 0x0f)
6200                     {
6201                       case 0x00:
6202                         goto op_semantics_41;
6203                         break;
6204                       case 0x01:
6205                         goto op_semantics_42;
6206                         break;
6207                       case 0x02:
6208                         goto op_semantics_43;
6209                         break;
6210                       default: UNSUPPORTED(); break;
6211                     }
6212                   break;
6213                 case 0x7d:
6214                     GETBYTE ();
6215                     switch (op[3] & 0x0f)
6216                     {
6217                       case 0x00:
6218                         goto op_semantics_44;
6219                         break;
6220                       case 0x08:
6221                         goto op_semantics_45;
6222                         break;
6223                       case 0x09:
6224                         goto op_semantics_46;
6225                         break;
6226                       case 0x0c:
6227                         goto op_semantics_47;
6228                         break;
6229                       case 0x0d:
6230                         goto op_semantics_48;
6231                         break;
6232                       default: UNSUPPORTED(); break;
6233                     }
6234                   break;
6235                 case 0x80:
6236                     GETBYTE ();
6237                     switch (op[3] & 0x00)
6238                     {
6239                       case 0x00:
6240                         goto op_semantics_36;
6241                         break;
6242                     }
6243                   break;
6244                 case 0x81:
6245                     GETBYTE ();
6246                     switch (op[3] & 0x00)
6247                     {
6248                       case 0x00:
6249                         goto op_semantics_37;
6250                         break;
6251                     }
6252                   break;
6253                 case 0x82:
6254                     GETBYTE ();
6255                     switch (op[3] & 0x00)
6256                     {
6257                       case 0x00:
6258                         goto op_semantics_38;
6259                         break;
6260                     }
6261                   break;
6262                 case 0x85:
6263                     GETBYTE ();
6264                     switch (op[3] & 0x00)
6265                     {
6266                       case 0x00:
6267                         goto op_semantics_39;
6268                         break;
6269                     }
6270                   break;
6271                 case 0x88:
6272                     GETBYTE ();
6273                     switch (op[3] & 0x00)
6274                     {
6275                       case 0x00:
6276                         goto op_semantics_40;
6277                         break;
6278                     }
6279                   break;
6280                 case 0x8c:
6281                     GETBYTE ();
6282                     switch (op[3] & 0x0f)
6283                     {
6284                       case 0x00:
6285                         goto op_semantics_41;
6286                         break;
6287                       case 0x01:
6288                         goto op_semantics_42;
6289                         break;
6290                       case 0x02:
6291                         goto op_semantics_43;
6292                         break;
6293                       default: UNSUPPORTED(); break;
6294                     }
6295                   break;
6296                 case 0x8d:
6297                     GETBYTE ();
6298                     switch (op[3] & 0x0f)
6299                     {
6300                       case 0x00:
6301                         goto op_semantics_44;
6302                         break;
6303                       case 0x08:
6304                         goto op_semantics_45;
6305                         break;
6306                       case 0x09:
6307                         goto op_semantics_46;
6308                         break;
6309                       case 0x0c:
6310                         goto op_semantics_47;
6311                         break;
6312                       case 0x0d:
6313                         goto op_semantics_48;
6314                         break;
6315                       default: UNSUPPORTED(); break;
6316                     }
6317                   break;
6318                 case 0x90:
6319                     GETBYTE ();
6320                     switch (op[3] & 0x00)
6321                     {
6322                       case 0x00:
6323                         goto op_semantics_36;
6324                         break;
6325                     }
6326                   break;
6327                 case 0x91:
6328                     GETBYTE ();
6329                     switch (op[3] & 0x00)
6330                     {
6331                       case 0x00:
6332                         goto op_semantics_37;
6333                         break;
6334                     }
6335                   break;
6336                 case 0x92:
6337                     GETBYTE ();
6338                     switch (op[3] & 0x00)
6339                     {
6340                       case 0x00:
6341                         goto op_semantics_38;
6342                         break;
6343                     }
6344                   break;
6345                 case 0x95:
6346                     GETBYTE ();
6347                     switch (op[3] & 0x00)
6348                     {
6349                       case 0x00:
6350                         goto op_semantics_39;
6351                         break;
6352                     }
6353                   break;
6354                 case 0x98:
6355                     GETBYTE ();
6356                     switch (op[3] & 0x00)
6357                     {
6358                       case 0x00:
6359                         goto op_semantics_40;
6360                         break;
6361                     }
6362                   break;
6363                 case 0x9c:
6364                     GETBYTE ();
6365                     switch (op[3] & 0x0f)
6366                     {
6367                       case 0x00:
6368                         goto op_semantics_41;
6369                         break;
6370                       case 0x01:
6371                         goto op_semantics_42;
6372                         break;
6373                       case 0x02:
6374                         goto op_semantics_43;
6375                         break;
6376                       default: UNSUPPORTED(); break;
6377                     }
6378                   break;
6379                 case 0x9d:
6380                     GETBYTE ();
6381                     switch (op[3] & 0x0f)
6382                     {
6383                       case 0x00:
6384                         goto op_semantics_44;
6385                         break;
6386                       case 0x08:
6387                         goto op_semantics_45;
6388                         break;
6389                       case 0x09:
6390                         goto op_semantics_46;
6391                         break;
6392                       case 0x0c:
6393                         goto op_semantics_47;
6394                         break;
6395                       case 0x0d:
6396                         goto op_semantics_48;
6397                         break;
6398                       default: UNSUPPORTED(); break;
6399                     }
6400                   break;
6401                 case 0xa0:
6402                     GETBYTE ();
6403                     switch (op[3] & 0x00)
6404                     {
6405                       case 0x00:
6406                         goto op_semantics_36;
6407                         break;
6408                     }
6409                   break;
6410                 case 0xa1:
6411                     GETBYTE ();
6412                     switch (op[3] & 0x00)
6413                     {
6414                       case 0x00:
6415                         goto op_semantics_37;
6416                         break;
6417                     }
6418                   break;
6419                 case 0xa2:
6420                     GETBYTE ();
6421                     switch (op[3] & 0x00)
6422                     {
6423                       case 0x00:
6424                         goto op_semantics_38;
6425                         break;
6426                     }
6427                   break;
6428                 case 0xa5:
6429                     GETBYTE ();
6430                     switch (op[3] & 0x00)
6431                     {
6432                       case 0x00:
6433                         goto op_semantics_39;
6434                         break;
6435                     }
6436                   break;
6437                 case 0xa8:
6438                     GETBYTE ();
6439                     switch (op[3] & 0x00)
6440                     {
6441                       case 0x00:
6442                         goto op_semantics_40;
6443                         break;
6444                     }
6445                   break;
6446                 case 0xac:
6447                     GETBYTE ();
6448                     switch (op[3] & 0x0f)
6449                     {
6450                       case 0x00:
6451                         goto op_semantics_41;
6452                         break;
6453                       case 0x01:
6454                         goto op_semantics_42;
6455                         break;
6456                       case 0x02:
6457                         goto op_semantics_43;
6458                         break;
6459                       default: UNSUPPORTED(); break;
6460                     }
6461                   break;
6462                 case 0xad:
6463                     GETBYTE ();
6464                     switch (op[3] & 0x0f)
6465                     {
6466                       case 0x00:
6467                         goto op_semantics_44;
6468                         break;
6469                       case 0x08:
6470                         goto op_semantics_45;
6471                         break;
6472                       case 0x09:
6473                         goto op_semantics_46;
6474                         break;
6475                       case 0x0c:
6476                         goto op_semantics_47;
6477                         break;
6478                       case 0x0d:
6479                         goto op_semantics_48;
6480                         break;
6481                       default: UNSUPPORTED(); break;
6482                     }
6483                   break;
6484                 case 0xb0:
6485                     GETBYTE ();
6486                     switch (op[3] & 0x00)
6487                     {
6488                       case 0x00:
6489                         goto op_semantics_36;
6490                         break;
6491                     }
6492                   break;
6493                 case 0xb1:
6494                     GETBYTE ();
6495                     switch (op[3] & 0x00)
6496                     {
6497                       case 0x00:
6498                         goto op_semantics_37;
6499                         break;
6500                     }
6501                   break;
6502                 case 0xb2:
6503                     GETBYTE ();
6504                     switch (op[3] & 0x00)
6505                     {
6506                       case 0x00:
6507                         goto op_semantics_38;
6508                         break;
6509                     }
6510                   break;
6511                 case 0xb5:
6512                     GETBYTE ();
6513                     switch (op[3] & 0x00)
6514                     {
6515                       case 0x00:
6516                         goto op_semantics_39;
6517                         break;
6518                     }
6519                   break;
6520                 case 0xb8:
6521                     GETBYTE ();
6522                     switch (op[3] & 0x00)
6523                     {
6524                       case 0x00:
6525                         goto op_semantics_40;
6526                         break;
6527                     }
6528                   break;
6529                 case 0xbc:
6530                     GETBYTE ();
6531                     switch (op[3] & 0x0f)
6532                     {
6533                       case 0x00:
6534                         goto op_semantics_41;
6535                         break;
6536                       case 0x01:
6537                         goto op_semantics_42;
6538                         break;
6539                       case 0x02:
6540                         goto op_semantics_43;
6541                         break;
6542                       default: UNSUPPORTED(); break;
6543                     }
6544                   break;
6545                 case 0xbd:
6546                     GETBYTE ();
6547                     switch (op[3] & 0x0f)
6548                     {
6549                       case 0x00:
6550                         goto op_semantics_44;
6551                         break;
6552                       case 0x08:
6553                         goto op_semantics_45;
6554                         break;
6555                       case 0x09:
6556                         goto op_semantics_46;
6557                         break;
6558                       case 0x0c:
6559                         goto op_semantics_47;
6560                         break;
6561                       case 0x0d:
6562                         goto op_semantics_48;
6563                         break;
6564                       default: UNSUPPORTED(); break;
6565                     }
6566                   break;
6567                 case 0xc0:
6568                     GETBYTE ();
6569                     switch (op[3] & 0x00)
6570                     {
6571                       case 0x00:
6572                         goto op_semantics_36;
6573                         break;
6574                     }
6575                   break;
6576                 case 0xc1:
6577                     GETBYTE ();
6578                     switch (op[3] & 0x00)
6579                     {
6580                       case 0x00:
6581                         goto op_semantics_37;
6582                         break;
6583                     }
6584                   break;
6585                 case 0xc2:
6586                     GETBYTE ();
6587                     switch (op[3] & 0x00)
6588                     {
6589                       case 0x00:
6590                         goto op_semantics_38;
6591                         break;
6592                     }
6593                   break;
6594                 case 0xc5:
6595                     GETBYTE ();
6596                     switch (op[3] & 0x00)
6597                     {
6598                       case 0x00:
6599                         goto op_semantics_39;
6600                         break;
6601                     }
6602                   break;
6603                 case 0xc8:
6604                     GETBYTE ();
6605                     switch (op[3] & 0x00)
6606                     {
6607                       case 0x00:
6608                         goto op_semantics_40;
6609                         break;
6610                     }
6611                   break;
6612                 case 0xcc:
6613                     GETBYTE ();
6614                     switch (op[3] & 0x0f)
6615                     {
6616                       case 0x00:
6617                         goto op_semantics_41;
6618                         break;
6619                       case 0x01:
6620                         goto op_semantics_42;
6621                         break;
6622                       case 0x02:
6623                         goto op_semantics_43;
6624                         break;
6625                       default: UNSUPPORTED(); break;
6626                     }
6627                   break;
6628                 case 0xcd:
6629                     GETBYTE ();
6630                     switch (op[3] & 0x0f)
6631                     {
6632                       case 0x00:
6633                         goto op_semantics_44;
6634                         break;
6635                       case 0x08:
6636                         goto op_semantics_45;
6637                         break;
6638                       case 0x09:
6639                         goto op_semantics_46;
6640                         break;
6641                       case 0x0c:
6642                         goto op_semantics_47;
6643                         break;
6644                       case 0x0d:
6645                         goto op_semantics_48;
6646                         break;
6647                       default: UNSUPPORTED(); break;
6648                     }
6649                   break;
6650                 case 0xd0:
6651                     GETBYTE ();
6652                     switch (op[3] & 0x00)
6653                     {
6654                       case 0x00:
6655                         goto op_semantics_36;
6656                         break;
6657                     }
6658                   break;
6659                 case 0xd1:
6660                     GETBYTE ();
6661                     switch (op[3] & 0x00)
6662                     {
6663                       case 0x00:
6664                         goto op_semantics_37;
6665                         break;
6666                     }
6667                   break;
6668                 case 0xd2:
6669                     GETBYTE ();
6670                     switch (op[3] & 0x00)
6671                     {
6672                       case 0x00:
6673                         goto op_semantics_38;
6674                         break;
6675                     }
6676                   break;
6677                 case 0xd5:
6678                     GETBYTE ();
6679                     switch (op[3] & 0x00)
6680                     {
6681                       case 0x00:
6682                         goto op_semantics_39;
6683                         break;
6684                     }
6685                   break;
6686                 case 0xd8:
6687                     GETBYTE ();
6688                     switch (op[3] & 0x00)
6689                     {
6690                       case 0x00:
6691                         goto op_semantics_40;
6692                         break;
6693                     }
6694                   break;
6695                 case 0xdc:
6696                     GETBYTE ();
6697                     switch (op[3] & 0x0f)
6698                     {
6699                       case 0x00:
6700                         goto op_semantics_41;
6701                         break;
6702                       case 0x01:
6703                         goto op_semantics_42;
6704                         break;
6705                       case 0x02:
6706                         goto op_semantics_43;
6707                         break;
6708                       default: UNSUPPORTED(); break;
6709                     }
6710                   break;
6711                 case 0xdd:
6712                     GETBYTE ();
6713                     switch (op[3] & 0x0f)
6714                     {
6715                       case 0x00:
6716                         goto op_semantics_44;
6717                         break;
6718                       case 0x08:
6719                         goto op_semantics_45;
6720                         break;
6721                       case 0x09:
6722                         goto op_semantics_46;
6723                         break;
6724                       case 0x0c:
6725                         goto op_semantics_47;
6726                         break;
6727                       case 0x0d:
6728                         goto op_semantics_48;
6729                         break;
6730                       default: UNSUPPORTED(); break;
6731                     }
6732                   break;
6733                 case 0xe0:
6734                     GETBYTE ();
6735                     switch (op[3] & 0x00)
6736                     {
6737                       case 0x00:
6738                         goto op_semantics_36;
6739                         break;
6740                     }
6741                   break;
6742                 case 0xe1:
6743                     GETBYTE ();
6744                     switch (op[3] & 0x00)
6745                     {
6746                       case 0x00:
6747                         goto op_semantics_37;
6748                         break;
6749                     }
6750                   break;
6751                 case 0xe2:
6752                     GETBYTE ();
6753                     switch (op[3] & 0x00)
6754                     {
6755                       case 0x00:
6756                         goto op_semantics_38;
6757                         break;
6758                     }
6759                   break;
6760                 case 0xe5:
6761                     GETBYTE ();
6762                     switch (op[3] & 0x00)
6763                     {
6764                       case 0x00:
6765                         goto op_semantics_39;
6766                         break;
6767                     }
6768                   break;
6769                 case 0xe8:
6770                     GETBYTE ();
6771                     switch (op[3] & 0x00)
6772                     {
6773                       case 0x00:
6774                         goto op_semantics_40;
6775                         break;
6776                     }
6777                   break;
6778                 case 0xec:
6779                     GETBYTE ();
6780                     switch (op[3] & 0x0f)
6781                     {
6782                       case 0x00:
6783                         goto op_semantics_41;
6784                         break;
6785                       case 0x01:
6786                         goto op_semantics_42;
6787                         break;
6788                       case 0x02:
6789                         goto op_semantics_43;
6790                         break;
6791                       default: UNSUPPORTED(); break;
6792                     }
6793                   break;
6794                 case 0xed:
6795                     GETBYTE ();
6796                     switch (op[3] & 0x0f)
6797                     {
6798                       case 0x00:
6799                         goto op_semantics_44;
6800                         break;
6801                       case 0x08:
6802                         goto op_semantics_45;
6803                         break;
6804                       case 0x09:
6805                         goto op_semantics_46;
6806                         break;
6807                       case 0x0c:
6808                         goto op_semantics_47;
6809                         break;
6810                       case 0x0d:
6811                         goto op_semantics_48;
6812                         break;
6813                       default: UNSUPPORTED(); break;
6814                     }
6815                   break;
6816                 case 0xf0:
6817                     GETBYTE ();
6818                     switch (op[3] & 0x00)
6819                     {
6820                       case 0x00:
6821                         goto op_semantics_36;
6822                         break;
6823                     }
6824                   break;
6825                 case 0xf1:
6826                     GETBYTE ();
6827                     switch (op[3] & 0x00)
6828                     {
6829                       case 0x00:
6830                         goto op_semantics_37;
6831                         break;
6832                     }
6833                   break;
6834                 case 0xf2:
6835                     GETBYTE ();
6836                     switch (op[3] & 0x00)
6837                     {
6838                       case 0x00:
6839                         goto op_semantics_38;
6840                         break;
6841                     }
6842                   break;
6843                 case 0xf5:
6844                     GETBYTE ();
6845                     switch (op[3] & 0x00)
6846                     {
6847                       case 0x00:
6848                         goto op_semantics_39;
6849                         break;
6850                     }
6851                   break;
6852                 case 0xf8:
6853                     GETBYTE ();
6854                     switch (op[3] & 0x00)
6855                     {
6856                       case 0x00:
6857                         goto op_semantics_40;
6858                         break;
6859                     }
6860                   break;
6861                 case 0xfc:
6862                     GETBYTE ();
6863                     switch (op[3] & 0x0f)
6864                     {
6865                       case 0x00:
6866                         goto op_semantics_41;
6867                         break;
6868                       case 0x01:
6869                         goto op_semantics_42;
6870                         break;
6871                       case 0x02:
6872                         goto op_semantics_43;
6873                         break;
6874                       default: UNSUPPORTED(); break;
6875                     }
6876                   break;
6877                 case 0xfd:
6878                     GETBYTE ();
6879                     switch (op[3] & 0x0f)
6880                     {
6881                       case 0x00:
6882                         goto op_semantics_44;
6883                         break;
6884                       case 0x08:
6885                         goto op_semantics_45;
6886                         break;
6887                       case 0x09:
6888                         goto op_semantics_46;
6889                         break;
6890                       case 0x0c:
6891                         goto op_semantics_47;
6892                         break;
6893                       case 0x0d:
6894                         goto op_semantics_48;
6895                         break;
6896                       default: UNSUPPORTED(); break;
6897                     }
6898                   break;
6899                 default: UNSUPPORTED(); break;
6900               }
6901             break;
6902           default: UNSUPPORTED(); break;
6903         }
6904       break;
6905     case 0x77:
6906         GETBYTE ();
6907         switch (op[1] & 0xf0)
6908         {
6909           case 0x00:
6910             goto op_semantics_32;
6911             break;
6912           case 0x10:
6913             goto op_semantics_33;
6914             break;
6915           case 0x20:
6916             goto op_semantics_34;
6917             break;
6918           case 0x30:
6919             goto op_semantics_35;
6920             break;
6921           default: UNSUPPORTED(); break;
6922         }
6923       break;
6924     case 0x78:
6925         GETBYTE ();
6926         switch (op[1] & 0x00)
6927         {
6928           case 0x00:
6929             op_semantics_49:
6930               {
6931                 /** 0111 100b ittt rdst                 bset    #%1, %0 */
6932 #line 968 "rx-decode.opc"
6933                 int b AU = op[0] & 0x01;
6934 #line 968 "rx-decode.opc"
6935                 int ittt AU = (op[1] >> 4) & 0x0f;
6936 #line 968 "rx-decode.opc"
6937                 int rdst AU = op[1] & 0x0f;
6938                 if (trace)
6939                   {
6940                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6941                            "/** 0111 100b ittt rdst                     bset    #%1, %0 */",
6942                            op[0], op[1]);
6943                     printf ("  b = 0x%x,", b);
6944                     printf ("  ittt = 0x%x,", ittt);
6945                     printf ("  rdst = 0x%x\n", rdst);
6946                   }
6947                 SYNTAX("bset    #%1, %0");
6948 #line 968 "rx-decode.opc"
6949                 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6950
6951
6952               }
6953             break;
6954         }
6955       break;
6956     case 0x79:
6957         GETBYTE ();
6958         switch (op[1] & 0x00)
6959         {
6960           case 0x00:
6961             goto op_semantics_49;
6962             break;
6963         }
6964       break;
6965     case 0x7a:
6966         GETBYTE ();
6967         switch (op[1] & 0x00)
6968         {
6969           case 0x00:
6970             op_semantics_50:
6971               {
6972                 /** 0111 101b ittt rdst                 bclr    #%1, %0 */
6973 #line 980 "rx-decode.opc"
6974                 int b AU = op[0] & 0x01;
6975 #line 980 "rx-decode.opc"
6976                 int ittt AU = (op[1] >> 4) & 0x0f;
6977 #line 980 "rx-decode.opc"
6978                 int rdst AU = op[1] & 0x0f;
6979                 if (trace)
6980                   {
6981                     printf ("\033[33m%s\033[0m  %02x %02x\n",
6982                            "/** 0111 101b ittt rdst                     bclr    #%1, %0 */",
6983                            op[0], op[1]);
6984                     printf ("  b = 0x%x,", b);
6985                     printf ("  ittt = 0x%x,", ittt);
6986                     printf ("  rdst = 0x%x\n", rdst);
6987                   }
6988                 SYNTAX("bclr    #%1, %0");
6989 #line 980 "rx-decode.opc"
6990                 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
6991
6992
6993               }
6994             break;
6995         }
6996       break;
6997     case 0x7b:
6998         GETBYTE ();
6999         switch (op[1] & 0x00)
7000         {
7001           case 0x00:
7002             goto op_semantics_50;
7003             break;
7004         }
7005       break;
7006     case 0x7c:
7007         GETBYTE ();
7008         switch (op[1] & 0x00)
7009         {
7010           case 0x00:
7011             op_semantics_51:
7012               {
7013                 /** 0111 110b ittt rdst                 btst    #%2, %1 */
7014 #line 992 "rx-decode.opc"
7015                 int b AU = op[0] & 0x01;
7016 #line 992 "rx-decode.opc"
7017                 int ittt AU = (op[1] >> 4) & 0x0f;
7018 #line 992 "rx-decode.opc"
7019                 int rdst AU = op[1] & 0x0f;
7020                 if (trace)
7021                   {
7022                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7023                            "/** 0111 110b ittt rdst                     btst    #%2, %1 */",
7024                            op[0], op[1]);
7025                     printf ("  b = 0x%x,", b);
7026                     printf ("  ittt = 0x%x,", ittt);
7027                     printf ("  rdst = 0x%x\n", rdst);
7028                   }
7029                 SYNTAX("btst    #%2, %1");
7030 #line 992 "rx-decode.opc"
7031                 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
7032
7033
7034               }
7035             break;
7036         }
7037       break;
7038     case 0x7d:
7039         GETBYTE ();
7040         switch (op[1] & 0x00)
7041         {
7042           case 0x00:
7043             goto op_semantics_51;
7044             break;
7045         }
7046       break;
7047     case 0x7e:
7048         GETBYTE ();
7049         switch (op[1] & 0xf0)
7050         {
7051           case 0x00:
7052               {
7053                 /** 0111 1110 0000 rdst                 not     %0 */
7054 #line 483 "rx-decode.opc"
7055                 int rdst AU = op[1] & 0x0f;
7056                 if (trace)
7057                   {
7058                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7059                            "/** 0111 1110 0000 rdst                     not     %0 */",
7060                            op[0], op[1]);
7061                     printf ("  rdst = 0x%x\n", rdst);
7062                   }
7063                 SYNTAX("not     %0");
7064 #line 483 "rx-decode.opc"
7065                 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
7066
7067               }
7068             break;
7069           case 0x10:
7070               {
7071                 /** 0111 1110 0001 rdst                 neg     %0 */
7072 #line 504 "rx-decode.opc"
7073                 int rdst AU = op[1] & 0x0f;
7074                 if (trace)
7075                   {
7076                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7077                            "/** 0111 1110 0001 rdst                     neg     %0 */",
7078                            op[0], op[1]);
7079                     printf ("  rdst = 0x%x\n", rdst);
7080                   }
7081                 SYNTAX("neg     %0");
7082 #line 504 "rx-decode.opc"
7083                 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
7084
7085               }
7086             break;
7087           case 0x20:
7088               {
7089                 /** 0111 1110 0010 rdst                 abs     %0 */
7090 #line 586 "rx-decode.opc"
7091                 int rdst AU = op[1] & 0x0f;
7092                 if (trace)
7093                   {
7094                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7095                            "/** 0111 1110 0010 rdst                     abs     %0 */",
7096                            op[0], op[1]);
7097                     printf ("  rdst = 0x%x\n", rdst);
7098                   }
7099                 SYNTAX("abs     %0");
7100 #line 586 "rx-decode.opc"
7101                 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
7102
7103               }
7104             break;
7105           case 0x30:
7106               {
7107                 /** 0111 1110 0011 rdst         sat     %0 */
7108 #line 906 "rx-decode.opc"
7109                 int rdst AU = op[1] & 0x0f;
7110                 if (trace)
7111                   {
7112                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7113                            "/** 0111 1110 0011 rdst             sat     %0 */",
7114                            op[0], op[1]);
7115                     printf ("  rdst = 0x%x\n", rdst);
7116                   }
7117                 SYNTAX("sat     %0");
7118 #line 906 "rx-decode.opc"
7119                 ID(sat); DR (rdst);
7120
7121               }
7122             break;
7123           case 0x40:
7124               {
7125                 /** 0111 1110 0100 rdst                 rorc    %0 */
7126 #line 766 "rx-decode.opc"
7127                 int rdst AU = op[1] & 0x0f;
7128                 if (trace)
7129                   {
7130                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7131                            "/** 0111 1110 0100 rdst                     rorc    %0 */",
7132                            op[0], op[1]);
7133                     printf ("  rdst = 0x%x\n", rdst);
7134                   }
7135                 SYNTAX("rorc    %0");
7136 #line 766 "rx-decode.opc"
7137                 ID(rorc); DR(rdst); F__SZC;
7138
7139               }
7140             break;
7141           case 0x50:
7142               {
7143                 /** 0111 1110 0101 rdst                 rolc    %0 */
7144 #line 763 "rx-decode.opc"
7145                 int rdst AU = op[1] & 0x0f;
7146                 if (trace)
7147                   {
7148                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7149                            "/** 0111 1110 0101 rdst                     rolc    %0 */",
7150                            op[0], op[1]);
7151                     printf ("  rdst = 0x%x\n", rdst);
7152                   }
7153                 SYNTAX("rolc    %0");
7154 #line 763 "rx-decode.opc"
7155                 ID(rolc); DR(rdst); F__SZC;
7156
7157               }
7158             break;
7159           case 0x80:
7160           case 0x90:
7161           case 0xa0:
7162               {
7163                 /** 0111 1110 10sz rsrc         push%s  %1 */
7164 #line 399 "rx-decode.opc"
7165                 int sz AU = (op[1] >> 4) & 0x03;
7166 #line 399 "rx-decode.opc"
7167                 int rsrc AU = op[1] & 0x0f;
7168                 if (trace)
7169                   {
7170                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7171                            "/** 0111 1110 10sz rsrc             push%s  %1 */",
7172                            op[0], op[1]);
7173                     printf ("  sz = 0x%x,", sz);
7174                     printf ("  rsrc = 0x%x\n", rsrc);
7175                   }
7176                 SYNTAX("push%s  %1");
7177 #line 399 "rx-decode.opc"
7178                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____;
7179
7180               }
7181             break;
7182           case 0xb0:
7183               {
7184                 /** 0111 1110 1011 rdst         pop     %0 */
7185 #line 396 "rx-decode.opc"
7186                 int rdst AU = op[1] & 0x0f;
7187                 if (trace)
7188                   {
7189                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7190                            "/** 0111 1110 1011 rdst             pop     %0 */",
7191                            op[0], op[1]);
7192                     printf ("  rdst = 0x%x\n", rdst);
7193                   }
7194                 SYNTAX("pop     %0");
7195 #line 396 "rx-decode.opc"
7196                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
7197
7198               }
7199             break;
7200           case 0xc0:
7201           case 0xd0:
7202               {
7203                 /** 0111 1110 110 crsrc                 pushc   %1 */
7204 #line 1029 "rx-decode.opc"
7205                 int crsrc AU = op[1] & 0x1f;
7206                 if (trace)
7207                   {
7208                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7209                            "/** 0111 1110 110 crsrc                     pushc   %1 */",
7210                            op[0], op[1]);
7211                     printf ("  crsrc = 0x%x\n", crsrc);
7212                   }
7213                 SYNTAX("pushc   %1");
7214 #line 1029 "rx-decode.opc"
7215                 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
7216
7217               }
7218             break;
7219           case 0xe0:
7220           case 0xf0:
7221               {
7222                 /** 0111 1110 111 crdst                 popc    %0 */
7223 #line 1026 "rx-decode.opc"
7224                 int crdst AU = op[1] & 0x1f;
7225                 if (trace)
7226                   {
7227                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7228                            "/** 0111 1110 111 crdst                     popc    %0 */",
7229                            op[0], op[1]);
7230                     printf ("  crdst = 0x%x\n", crdst);
7231                   }
7232                 SYNTAX("popc    %0");
7233 #line 1026 "rx-decode.opc"
7234                 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
7235
7236               }
7237             break;
7238           default: UNSUPPORTED(); break;
7239         }
7240       break;
7241     case 0x7f:
7242         GETBYTE ();
7243         switch (op[1] & 0xff)
7244         {
7245           case 0x00:
7246           case 0x01:
7247           case 0x02:
7248           case 0x03:
7249           case 0x04:
7250           case 0x05:
7251           case 0x06:
7252           case 0x07:
7253           case 0x08:
7254           case 0x09:
7255           case 0x0a:
7256           case 0x0b:
7257           case 0x0c:
7258           case 0x0d:
7259           case 0x0e:
7260           case 0x0f:
7261               {
7262                 /** 0111 1111 0000 rsrc         jmp     %0 */
7263 #line 816 "rx-decode.opc"
7264                 int rsrc AU = op[1] & 0x0f;
7265                 if (trace)
7266                   {
7267                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7268                            "/** 0111 1111 0000 rsrc             jmp     %0 */",
7269                            op[0], op[1]);
7270                     printf ("  rsrc = 0x%x\n", rsrc);
7271                   }
7272                 SYNTAX("jmp     %0");
7273 #line 816 "rx-decode.opc"
7274                 ID(branch); DR(rsrc);
7275
7276               }
7277             break;
7278           case 0x10:
7279           case 0x11:
7280           case 0x12:
7281           case 0x13:
7282           case 0x14:
7283           case 0x15:
7284           case 0x16:
7285           case 0x17:
7286           case 0x18:
7287           case 0x19:
7288           case 0x1a:
7289           case 0x1b:
7290           case 0x1c:
7291           case 0x1d:
7292           case 0x1e:
7293           case 0x1f:
7294               {
7295                 /** 0111 1111 0001 rsrc         jsr     %0 */
7296 #line 819 "rx-decode.opc"
7297                 int rsrc AU = op[1] & 0x0f;
7298                 if (trace)
7299                   {
7300                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7301                            "/** 0111 1111 0001 rsrc             jsr     %0 */",
7302                            op[0], op[1]);
7303                     printf ("  rsrc = 0x%x\n", rsrc);
7304                   }
7305                 SYNTAX("jsr     %0");
7306 #line 819 "rx-decode.opc"
7307                 ID(jsr); DR(rsrc);
7308
7309               }
7310             break;
7311           case 0x40:
7312           case 0x41:
7313           case 0x42:
7314           case 0x43:
7315           case 0x44:
7316           case 0x45:
7317           case 0x46:
7318           case 0x47:
7319           case 0x48:
7320           case 0x49:
7321           case 0x4a:
7322           case 0x4b:
7323           case 0x4c:
7324           case 0x4d:
7325           case 0x4e:
7326           case 0x4f:
7327               {
7328                 /** 0111 1111 0100 rsrc         bra.l   %0 */
7329 #line 812 "rx-decode.opc"
7330                 int rsrc AU = op[1] & 0x0f;
7331                 if (trace)
7332                   {
7333                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7334                            "/** 0111 1111 0100 rsrc             bra.l   %0 */",
7335                            op[0], op[1]);
7336                     printf ("  rsrc = 0x%x\n", rsrc);
7337                   }
7338                 SYNTAX("bra.l   %0");
7339 #line 812 "rx-decode.opc"
7340                 ID(branchrel); DR(rsrc);
7341
7342
7343               }
7344             break;
7345           case 0x50:
7346           case 0x51:
7347           case 0x52:
7348           case 0x53:
7349           case 0x54:
7350           case 0x55:
7351           case 0x56:
7352           case 0x57:
7353           case 0x58:
7354           case 0x59:
7355           case 0x5a:
7356           case 0x5b:
7357           case 0x5c:
7358           case 0x5d:
7359           case 0x5e:
7360           case 0x5f:
7361               {
7362                 /** 0111 1111 0101 rsrc         bsr.l   %0 */
7363 #line 828 "rx-decode.opc"
7364                 int rsrc AU = op[1] & 0x0f;
7365                 if (trace)
7366                   {
7367                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7368                            "/** 0111 1111 0101 rsrc             bsr.l   %0 */",
7369                            op[0], op[1]);
7370                     printf ("  rsrc = 0x%x\n", rsrc);
7371                   }
7372                 SYNTAX("bsr.l   %0");
7373 #line 828 "rx-decode.opc"
7374                 ID(jsrrel); DR(rsrc);
7375
7376               }
7377             break;
7378           case 0x80:
7379           case 0x81:
7380           case 0x82:
7381               {
7382                 /** 0111 1111 1000 00sz         suntil%s */
7383 #line 852 "rx-decode.opc"
7384                 int sz AU = op[1] & 0x03;
7385                 if (trace)
7386                   {
7387                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7388                            "/** 0111 1111 1000 00sz             suntil%s */",
7389                            op[0], op[1]);
7390                     printf ("  sz = 0x%x\n", sz);
7391                   }
7392                 SYNTAX("suntil%s");
7393 #line 852 "rx-decode.opc"
7394                 ID(suntil); BWL(sz); F___ZC;
7395
7396               }
7397             break;
7398           case 0x83:
7399               {
7400                 /** 0111 1111 1000 0011         scmpu */
7401                 if (trace)
7402                   {
7403                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7404                            "/** 0111 1111 1000 0011             scmpu */",
7405                            op[0], op[1]);
7406                   }
7407                 SYNTAX("scmpu");
7408 #line 843 "rx-decode.opc"
7409                 ID(scmpu); F___ZC;
7410
7411               }
7412             break;
7413           case 0x84:
7414           case 0x85:
7415           case 0x86:
7416               {
7417                 /** 0111 1111 1000 01sz         swhile%s */
7418 #line 855 "rx-decode.opc"
7419                 int sz AU = op[1] & 0x03;
7420                 if (trace)
7421                   {
7422                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7423                            "/** 0111 1111 1000 01sz             swhile%s */",
7424                            op[0], op[1]);
7425                     printf ("  sz = 0x%x\n", sz);
7426                   }
7427                 SYNTAX("swhile%s");
7428 #line 855 "rx-decode.opc"
7429                 ID(swhile); BWL(sz); F___ZC;
7430
7431               }
7432             break;
7433           case 0x87:
7434               {
7435                 /** 0111 1111 1000 0111         smovu */
7436                 if (trace)
7437                   {
7438                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7439                            "/** 0111 1111 1000 0111             smovu */",
7440                            op[0], op[1]);
7441                   }
7442                 SYNTAX("smovu");
7443 #line 846 "rx-decode.opc"
7444                 ID(smovu);
7445
7446               }
7447             break;
7448           case 0x88:
7449           case 0x89:
7450           case 0x8a:
7451               {
7452                 /** 0111 1111 1000 10sz         sstr%s */
7453 #line 861 "rx-decode.opc"
7454                 int sz AU = op[1] & 0x03;
7455                 if (trace)
7456                   {
7457                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7458                            "/** 0111 1111 1000 10sz             sstr%s */",
7459                            op[0], op[1]);
7460                     printf ("  sz = 0x%x\n", sz);
7461                   }
7462                 SYNTAX("sstr%s");
7463 #line 861 "rx-decode.opc"
7464                 ID(sstr); BWL(sz);
7465
7466               /*----------------------------------------------------------------------*/
7467               /* RMPA                                                                   */
7468
7469               }
7470             break;
7471           case 0x8b:
7472               {
7473                 /** 0111 1111 1000 1011         smovb */
7474                 if (trace)
7475                   {
7476                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7477                            "/** 0111 1111 1000 1011             smovb */",
7478                            op[0], op[1]);
7479                   }
7480                 SYNTAX("smovb");
7481 #line 849 "rx-decode.opc"
7482                 ID(smovb);
7483
7484               }
7485             break;
7486           case 0x8c:
7487           case 0x8d:
7488           case 0x8e:
7489               {
7490                 /** 0111 1111 1000 11sz         rmpa%s */
7491 #line 867 "rx-decode.opc"
7492                 int sz AU = op[1] & 0x03;
7493                 if (trace)
7494                   {
7495                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7496                            "/** 0111 1111 1000 11sz             rmpa%s */",
7497                            op[0], op[1]);
7498                     printf ("  sz = 0x%x\n", sz);
7499                   }
7500                 SYNTAX("rmpa%s");
7501 #line 867 "rx-decode.opc"
7502                 ID(rmpa); BWL(sz); F_OS__;
7503
7504               /*----------------------------------------------------------------------*/
7505               /* HI/LO stuff                                                            */
7506
7507               }
7508             break;
7509           case 0x8f:
7510               {
7511                 /** 0111 1111 1000 1111         smovf */
7512                 if (trace)
7513                   {
7514                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7515                            "/** 0111 1111 1000 1111             smovf */",
7516                            op[0], op[1]);
7517                   }
7518                 SYNTAX("smovf");
7519 #line 858 "rx-decode.opc"
7520                 ID(smovf);
7521
7522               }
7523             break;
7524           case 0x93:
7525               {
7526                 /** 0111 1111 1001 0011         satr */
7527                 if (trace)
7528                   {
7529                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7530                            "/** 0111 1111 1001 0011             satr */",
7531                            op[0], op[1]);
7532                   }
7533                 SYNTAX("satr");
7534 #line 909 "rx-decode.opc"
7535                 ID(satr);
7536
7537               /*----------------------------------------------------------------------*/
7538               /* FLOAT                                                          */
7539
7540               }
7541             break;
7542           case 0x94:
7543               {
7544                 /** 0111 1111 1001 0100         rtfi */
7545                 if (trace)
7546                   {
7547                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7548                            "/** 0111 1111 1001 0100             rtfi */",
7549                            op[0], op[1]);
7550                   }
7551                 SYNTAX("rtfi");
7552 #line 1044 "rx-decode.opc"
7553                 ID(rtfi);
7554
7555               }
7556             break;
7557           case 0x95:
7558               {
7559                 /** 0111 1111 1001 0101         rte */
7560                 if (trace)
7561                   {
7562                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7563                            "/** 0111 1111 1001 0101             rte */",
7564                            op[0], op[1]);
7565                   }
7566                 SYNTAX("rte");
7567 #line 1047 "rx-decode.opc"
7568                 ID(rte);
7569
7570               }
7571             break;
7572           case 0x96:
7573               {
7574                 /** 0111 1111 1001 0110         wait */
7575                 if (trace)
7576                   {
7577                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7578                            "/** 0111 1111 1001 0110             wait */",
7579                            op[0], op[1]);
7580                   }
7581                 SYNTAX("wait");
7582 #line 1059 "rx-decode.opc"
7583                 ID(wait);
7584
7585               /*----------------------------------------------------------------------*/
7586               /* SCcnd                                                          */
7587
7588               }
7589             break;
7590           case 0xa0:
7591           case 0xa1:
7592           case 0xa2:
7593           case 0xa3:
7594           case 0xa4:
7595           case 0xa5:
7596           case 0xa6:
7597           case 0xa7:
7598           case 0xa8:
7599           case 0xa9:
7600           case 0xaa:
7601           case 0xab:
7602           case 0xac:
7603           case 0xad:
7604           case 0xae:
7605           case 0xaf:
7606               {
7607                 /** 0111 1111 1010 rdst                 setpsw  %0 */
7608 #line 1020 "rx-decode.opc"
7609                 int rdst AU = op[1] & 0x0f;
7610                 if (trace)
7611                   {
7612                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7613                            "/** 0111 1111 1010 rdst                     setpsw  %0 */",
7614                            op[0], op[1]);
7615                     printf ("  rdst = 0x%x\n", rdst);
7616                   }
7617                 SYNTAX("setpsw  %0");
7618 #line 1020 "rx-decode.opc"
7619                 ID(setpsw); DF(rdst);
7620
7621               }
7622             break;
7623           case 0xb0:
7624           case 0xb1:
7625           case 0xb2:
7626           case 0xb3:
7627           case 0xb4:
7628           case 0xb5:
7629           case 0xb6:
7630           case 0xb7:
7631           case 0xb8:
7632           case 0xb9:
7633           case 0xba:
7634           case 0xbb:
7635           case 0xbc:
7636           case 0xbd:
7637           case 0xbe:
7638           case 0xbf:
7639               {
7640                 /** 0111 1111 1011 rdst                 clrpsw  %0 */
7641 #line 1017 "rx-decode.opc"
7642                 int rdst AU = op[1] & 0x0f;
7643                 if (trace)
7644                   {
7645                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7646                            "/** 0111 1111 1011 rdst                     clrpsw  %0 */",
7647                            op[0], op[1]);
7648                     printf ("  rdst = 0x%x\n", rdst);
7649                   }
7650                 SYNTAX("clrpsw  %0");
7651 #line 1017 "rx-decode.opc"
7652                 ID(clrpsw); DF(rdst);
7653
7654               }
7655             break;
7656           default: UNSUPPORTED(); break;
7657         }
7658       break;
7659     case 0x80:
7660         GETBYTE ();
7661         switch (op[1] & 0x00)
7662         {
7663           case 0x00:
7664             op_semantics_52:
7665               {
7666                 /** 10sz 0dsp a dst b src       mov%s   %1, %0 */
7667 #line 357 "rx-decode.opc"
7668                 int sz AU = (op[0] >> 4) & 0x03;
7669 #line 357 "rx-decode.opc"
7670                 int dsp AU = op[0] & 0x07;
7671 #line 357 "rx-decode.opc"
7672                 int a AU = (op[1] >> 7) & 0x01;
7673 #line 357 "rx-decode.opc"
7674                 int dst AU = (op[1] >> 4) & 0x07;
7675 #line 357 "rx-decode.opc"
7676                 int b AU = (op[1] >> 3) & 0x01;
7677 #line 357 "rx-decode.opc"
7678                 int src AU = op[1] & 0x07;
7679                 if (trace)
7680                   {
7681                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7682                            "/** 10sz 0dsp a dst b src   mov%s   %1, %0 */",
7683                            op[0], op[1]);
7684                     printf ("  sz = 0x%x,", sz);
7685                     printf ("  dsp = 0x%x,", dsp);
7686                     printf ("  a = 0x%x,", a);
7687                     printf ("  dst = 0x%x,", dst);
7688                     printf ("  b = 0x%x,", b);
7689                     printf ("  src = 0x%x\n", src);
7690                   }
7691                 SYNTAX("mov%s   %1, %0");
7692 #line 357 "rx-decode.opc"
7693                 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
7694
7695               }
7696             break;
7697         }
7698       break;
7699     case 0x81:
7700         GETBYTE ();
7701         switch (op[1] & 0x00)
7702         {
7703           case 0x00:
7704             goto op_semantics_52;
7705             break;
7706         }
7707       break;
7708     case 0x82:
7709         GETBYTE ();
7710         switch (op[1] & 0x00)
7711         {
7712           case 0x00:
7713             goto op_semantics_52;
7714             break;
7715         }
7716       break;
7717     case 0x83:
7718         GETBYTE ();
7719         switch (op[1] & 0x00)
7720         {
7721           case 0x00:
7722             goto op_semantics_52;
7723             break;
7724         }
7725       break;
7726     case 0x84:
7727         GETBYTE ();
7728         switch (op[1] & 0x00)
7729         {
7730           case 0x00:
7731             goto op_semantics_52;
7732             break;
7733         }
7734       break;
7735     case 0x85:
7736         GETBYTE ();
7737         switch (op[1] & 0x00)
7738         {
7739           case 0x00:
7740             goto op_semantics_52;
7741             break;
7742         }
7743       break;
7744     case 0x86:
7745         GETBYTE ();
7746         switch (op[1] & 0x00)
7747         {
7748           case 0x00:
7749             goto op_semantics_52;
7750             break;
7751         }
7752       break;
7753     case 0x87:
7754         GETBYTE ();
7755         switch (op[1] & 0x00)
7756         {
7757           case 0x00:
7758             goto op_semantics_52;
7759             break;
7760         }
7761       break;
7762     case 0x88:
7763         GETBYTE ();
7764         switch (op[1] & 0x00)
7765         {
7766           case 0x00:
7767             op_semantics_53:
7768               {
7769                 /** 10sz 1dsp a src b dst       mov%s   %1, %0 */
7770 #line 354 "rx-decode.opc"
7771                 int sz AU = (op[0] >> 4) & 0x03;
7772 #line 354 "rx-decode.opc"
7773                 int dsp AU = op[0] & 0x07;
7774 #line 354 "rx-decode.opc"
7775                 int a AU = (op[1] >> 7) & 0x01;
7776 #line 354 "rx-decode.opc"
7777                 int src AU = (op[1] >> 4) & 0x07;
7778 #line 354 "rx-decode.opc"
7779                 int b AU = (op[1] >> 3) & 0x01;
7780 #line 354 "rx-decode.opc"
7781                 int dst AU = op[1] & 0x07;
7782                 if (trace)
7783                   {
7784                     printf ("\033[33m%s\033[0m  %02x %02x\n",
7785                            "/** 10sz 1dsp a src b dst   mov%s   %1, %0 */",
7786                            op[0], op[1]);
7787                     printf ("  sz = 0x%x,", sz);
7788                     printf ("  dsp = 0x%x,", dsp);
7789                     printf ("  a = 0x%x,", a);
7790                     printf ("  src = 0x%x,", src);
7791                     printf ("  b = 0x%x,", b);
7792                     printf ("  dst = 0x%x\n", dst);
7793                   }
7794                 SYNTAX("mov%s   %1, %0");
7795 #line 354 "rx-decode.opc"
7796                 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
7797
7798               }
7799             break;
7800         }
7801       break;
7802     case 0x89:
7803         GETBYTE ();
7804         switch (op[1] & 0x00)
7805         {
7806           case 0x00:
7807             goto op_semantics_53;
7808             break;
7809         }
7810       break;
7811     case 0x8a:
7812         GETBYTE ();
7813         switch (op[1] & 0x00)
7814         {
7815           case 0x00:
7816             goto op_semantics_53;
7817             break;
7818         }
7819       break;
7820     case 0x8b:
7821         GETBYTE ();
7822         switch (op[1] & 0x00)
7823         {
7824           case 0x00:
7825             goto op_semantics_53;
7826             break;
7827         }
7828       break;
7829     case 0x8c:
7830         GETBYTE ();
7831         switch (op[1] & 0x00)
7832         {
7833           case 0x00:
7834             goto op_semantics_53;
7835             break;
7836         }
7837       break;
7838     case 0x8d:
7839         GETBYTE ();
7840         switch (op[1] & 0x00)
7841         {
7842           case 0x00:
7843             goto op_semantics_53;
7844             break;
7845         }
7846       break;
7847     case 0x8e:
7848         GETBYTE ();
7849         switch (op[1] & 0x00)
7850         {
7851           case 0x00:
7852             goto op_semantics_53;
7853             break;
7854         }
7855       break;
7856     case 0x8f:
7857         GETBYTE ();
7858         switch (op[1] & 0x00)
7859         {
7860           case 0x00:
7861             goto op_semantics_53;
7862             break;
7863         }
7864       break;
7865     case 0x90:
7866         GETBYTE ();
7867         switch (op[1] & 0x00)
7868         {
7869           case 0x00:
7870             goto op_semantics_52;
7871             break;
7872         }
7873       break;
7874     case 0x91:
7875         GETBYTE ();
7876         switch (op[1] & 0x00)
7877         {
7878           case 0x00:
7879             goto op_semantics_52;
7880             break;
7881         }
7882       break;
7883     case 0x92:
7884         GETBYTE ();
7885         switch (op[1] & 0x00)
7886         {
7887           case 0x00:
7888             goto op_semantics_52;
7889             break;
7890         }
7891       break;
7892     case 0x93:
7893         GETBYTE ();
7894         switch (op[1] & 0x00)
7895         {
7896           case 0x00:
7897             goto op_semantics_52;
7898             break;
7899         }
7900       break;
7901     case 0x94:
7902         GETBYTE ();
7903         switch (op[1] & 0x00)
7904         {
7905           case 0x00:
7906             goto op_semantics_52;
7907             break;
7908         }
7909       break;
7910     case 0x95:
7911         GETBYTE ();
7912         switch (op[1] & 0x00)
7913         {
7914           case 0x00:
7915             goto op_semantics_52;
7916             break;
7917         }
7918       break;
7919     case 0x96:
7920         GETBYTE ();
7921         switch (op[1] & 0x00)
7922         {
7923           case 0x00:
7924             goto op_semantics_52;
7925             break;
7926         }
7927       break;
7928     case 0x97:
7929         GETBYTE ();
7930         switch (op[1] & 0x00)
7931         {
7932           case 0x00:
7933             goto op_semantics_52;
7934             break;
7935         }
7936       break;
7937     case 0x98:
7938         GETBYTE ();
7939         switch (op[1] & 0x00)
7940         {
7941           case 0x00:
7942             goto op_semantics_53;
7943             break;
7944         }
7945       break;
7946     case 0x99:
7947         GETBYTE ();
7948         switch (op[1] & 0x00)
7949         {
7950           case 0x00:
7951             goto op_semantics_53;
7952             break;
7953         }
7954       break;
7955     case 0x9a:
7956         GETBYTE ();
7957         switch (op[1] & 0x00)
7958         {
7959           case 0x00:
7960             goto op_semantics_53;
7961             break;
7962         }
7963       break;
7964     case 0x9b:
7965         GETBYTE ();
7966         switch (op[1] & 0x00)
7967         {
7968           case 0x00:
7969             goto op_semantics_53;
7970             break;
7971         }
7972       break;
7973     case 0x9c:
7974         GETBYTE ();
7975         switch (op[1] & 0x00)
7976         {
7977           case 0x00:
7978             goto op_semantics_53;
7979             break;
7980         }
7981       break;
7982     case 0x9d:
7983         GETBYTE ();
7984         switch (op[1] & 0x00)
7985         {
7986           case 0x00:
7987             goto op_semantics_53;
7988             break;
7989         }
7990       break;
7991     case 0x9e:
7992         GETBYTE ();
7993         switch (op[1] & 0x00)
7994         {
7995           case 0x00:
7996             goto op_semantics_53;
7997             break;
7998         }
7999       break;
8000     case 0x9f:
8001         GETBYTE ();
8002         switch (op[1] & 0x00)
8003         {
8004           case 0x00:
8005             goto op_semantics_53;
8006             break;
8007         }
8008       break;
8009     case 0xa0:
8010         GETBYTE ();
8011         switch (op[1] & 0x00)
8012         {
8013           case 0x00:
8014             goto op_semantics_52;
8015             break;
8016         }
8017       break;
8018     case 0xa1:
8019         GETBYTE ();
8020         switch (op[1] & 0x00)
8021         {
8022           case 0x00:
8023             goto op_semantics_52;
8024             break;
8025         }
8026       break;
8027     case 0xa2:
8028         GETBYTE ();
8029         switch (op[1] & 0x00)
8030         {
8031           case 0x00:
8032             goto op_semantics_52;
8033             break;
8034         }
8035       break;
8036     case 0xa3:
8037         GETBYTE ();
8038         switch (op[1] & 0x00)
8039         {
8040           case 0x00:
8041             goto op_semantics_52;
8042             break;
8043         }
8044       break;
8045     case 0xa4:
8046         GETBYTE ();
8047         switch (op[1] & 0x00)
8048         {
8049           case 0x00:
8050             goto op_semantics_52;
8051             break;
8052         }
8053       break;
8054     case 0xa5:
8055         GETBYTE ();
8056         switch (op[1] & 0x00)
8057         {
8058           case 0x00:
8059             goto op_semantics_52;
8060             break;
8061         }
8062       break;
8063     case 0xa6:
8064         GETBYTE ();
8065         switch (op[1] & 0x00)
8066         {
8067           case 0x00:
8068             goto op_semantics_52;
8069             break;
8070         }
8071       break;
8072     case 0xa7:
8073         GETBYTE ();
8074         switch (op[1] & 0x00)
8075         {
8076           case 0x00:
8077             goto op_semantics_52;
8078             break;
8079         }
8080       break;
8081     case 0xa8:
8082         GETBYTE ();
8083         switch (op[1] & 0x00)
8084         {
8085           case 0x00:
8086             goto op_semantics_53;
8087             break;
8088         }
8089       break;
8090     case 0xa9:
8091         GETBYTE ();
8092         switch (op[1] & 0x00)
8093         {
8094           case 0x00:
8095             goto op_semantics_53;
8096             break;
8097         }
8098       break;
8099     case 0xaa:
8100         GETBYTE ();
8101         switch (op[1] & 0x00)
8102         {
8103           case 0x00:
8104             goto op_semantics_53;
8105             break;
8106         }
8107       break;
8108     case 0xab:
8109         GETBYTE ();
8110         switch (op[1] & 0x00)
8111         {
8112           case 0x00:
8113             goto op_semantics_53;
8114             break;
8115         }
8116       break;
8117     case 0xac:
8118         GETBYTE ();
8119         switch (op[1] & 0x00)
8120         {
8121           case 0x00:
8122             goto op_semantics_53;
8123             break;
8124         }
8125       break;
8126     case 0xad:
8127         GETBYTE ();
8128         switch (op[1] & 0x00)
8129         {
8130           case 0x00:
8131             goto op_semantics_53;
8132             break;
8133         }
8134       break;
8135     case 0xae:
8136         GETBYTE ();
8137         switch (op[1] & 0x00)
8138         {
8139           case 0x00:
8140             goto op_semantics_53;
8141             break;
8142         }
8143       break;
8144     case 0xaf:
8145         GETBYTE ();
8146         switch (op[1] & 0x00)
8147         {
8148           case 0x00:
8149             goto op_semantics_53;
8150             break;
8151         }
8152       break;
8153     case 0xb0:
8154         GETBYTE ();
8155         switch (op[1] & 0x00)
8156         {
8157           case 0x00:
8158             op_semantics_54:
8159               {
8160                 /** 1011 w dsp a src b dst      movu%s  %1, %0 */
8161 #line 377 "rx-decode.opc"
8162                 int w AU = (op[0] >> 3) & 0x01;
8163 #line 377 "rx-decode.opc"
8164                 int dsp AU = op[0] & 0x07;
8165 #line 377 "rx-decode.opc"
8166                 int a AU = (op[1] >> 7) & 0x01;
8167 #line 377 "rx-decode.opc"
8168                 int src AU = (op[1] >> 4) & 0x07;
8169 #line 377 "rx-decode.opc"
8170                 int b AU = (op[1] >> 3) & 0x01;
8171 #line 377 "rx-decode.opc"
8172                 int dst AU = op[1] & 0x07;
8173                 if (trace)
8174                   {
8175                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8176                            "/** 1011 w dsp a src b dst  movu%s  %1, %0 */",
8177                            op[0], op[1]);
8178                     printf ("  w = 0x%x,", w);
8179                     printf ("  dsp = 0x%x,", dsp);
8180                     printf ("  a = 0x%x,", a);
8181                     printf ("  src = 0x%x,", src);
8182                     printf ("  b = 0x%x,", b);
8183                     printf ("  dst = 0x%x\n", dst);
8184                   }
8185                 SYNTAX("movu%s  %1, %0");
8186 #line 377 "rx-decode.opc"
8187                 ID(mov); uBW(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
8188
8189               }
8190             break;
8191         }
8192       break;
8193     case 0xb1:
8194         GETBYTE ();
8195         switch (op[1] & 0x00)
8196         {
8197           case 0x00:
8198             goto op_semantics_54;
8199             break;
8200         }
8201       break;
8202     case 0xb2:
8203         GETBYTE ();
8204         switch (op[1] & 0x00)
8205         {
8206           case 0x00:
8207             goto op_semantics_54;
8208             break;
8209         }
8210       break;
8211     case 0xb3:
8212         GETBYTE ();
8213         switch (op[1] & 0x00)
8214         {
8215           case 0x00:
8216             goto op_semantics_54;
8217             break;
8218         }
8219       break;
8220     case 0xb4:
8221         GETBYTE ();
8222         switch (op[1] & 0x00)
8223         {
8224           case 0x00:
8225             goto op_semantics_54;
8226             break;
8227         }
8228       break;
8229     case 0xb5:
8230         GETBYTE ();
8231         switch (op[1] & 0x00)
8232         {
8233           case 0x00:
8234             goto op_semantics_54;
8235             break;
8236         }
8237       break;
8238     case 0xb6:
8239         GETBYTE ();
8240         switch (op[1] & 0x00)
8241         {
8242           case 0x00:
8243             goto op_semantics_54;
8244             break;
8245         }
8246       break;
8247     case 0xb7:
8248         GETBYTE ();
8249         switch (op[1] & 0x00)
8250         {
8251           case 0x00:
8252             goto op_semantics_54;
8253             break;
8254         }
8255       break;
8256     case 0xb8:
8257         GETBYTE ();
8258         switch (op[1] & 0x00)
8259         {
8260           case 0x00:
8261             goto op_semantics_54;
8262             break;
8263         }
8264       break;
8265     case 0xb9:
8266         GETBYTE ();
8267         switch (op[1] & 0x00)
8268         {
8269           case 0x00:
8270             goto op_semantics_54;
8271             break;
8272         }
8273       break;
8274     case 0xba:
8275         GETBYTE ();
8276         switch (op[1] & 0x00)
8277         {
8278           case 0x00:
8279             goto op_semantics_54;
8280             break;
8281         }
8282       break;
8283     case 0xbb:
8284         GETBYTE ();
8285         switch (op[1] & 0x00)
8286         {
8287           case 0x00:
8288             goto op_semantics_54;
8289             break;
8290         }
8291       break;
8292     case 0xbc:
8293         GETBYTE ();
8294         switch (op[1] & 0x00)
8295         {
8296           case 0x00:
8297             goto op_semantics_54;
8298             break;
8299         }
8300       break;
8301     case 0xbd:
8302         GETBYTE ();
8303         switch (op[1] & 0x00)
8304         {
8305           case 0x00:
8306             goto op_semantics_54;
8307             break;
8308         }
8309       break;
8310     case 0xbe:
8311         GETBYTE ();
8312         switch (op[1] & 0x00)
8313         {
8314           case 0x00:
8315             goto op_semantics_54;
8316             break;
8317         }
8318       break;
8319     case 0xbf:
8320         GETBYTE ();
8321         switch (op[1] & 0x00)
8322         {
8323           case 0x00:
8324             goto op_semantics_54;
8325             break;
8326         }
8327       break;
8328     case 0xc0:
8329         GETBYTE ();
8330         switch (op[1] & 0x00)
8331         {
8332           case 0x00:
8333             op_semantics_55:
8334               {
8335                 /** 11sz sd ss rsrc rdst        mov%s   %1, %0 */
8336 #line 335 "rx-decode.opc"
8337                 int sz AU = (op[0] >> 4) & 0x03;
8338 #line 335 "rx-decode.opc"
8339                 int sd AU = (op[0] >> 2) & 0x03;
8340 #line 335 "rx-decode.opc"
8341                 int ss AU = op[0] & 0x03;
8342 #line 335 "rx-decode.opc"
8343                 int rsrc AU = (op[1] >> 4) & 0x0f;
8344 #line 335 "rx-decode.opc"
8345                 int rdst AU = op[1] & 0x0f;
8346                 if (trace)
8347                   {
8348                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8349                            "/** 11sz sd ss rsrc rdst    mov%s   %1, %0 */",
8350                            op[0], op[1]);
8351                     printf ("  sz = 0x%x,", sz);
8352                     printf ("  sd = 0x%x,", sd);
8353                     printf ("  ss = 0x%x,", ss);
8354                     printf ("  rsrc = 0x%x,", rsrc);
8355                     printf ("  rdst = 0x%x\n", rdst);
8356                   }
8357                 SYNTAX("mov%s   %1, %0");
8358 #line 335 "rx-decode.opc"
8359                 if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
8360                   {
8361                     ID(nop2);
8362                     SYNTAX ("nop\t; mov.l\tr0, r0");
8363                   }
8364                 else
8365                   {
8366                     ID(mov); sBWL(sz); F_____;
8367                     if ((ss == 3) && (sd != 3))
8368                 {
8369                   SD(ss, rdst, sz); DD(sd, rsrc, sz);
8370                 }
8371                     else
8372                 {
8373                   SD(ss, rsrc, sz); DD(sd, rdst, sz);
8374                 }
8375                   }
8376
8377               }
8378             break;
8379         }
8380       break;
8381     case 0xc1:
8382         GETBYTE ();
8383         switch (op[1] & 0x00)
8384         {
8385           case 0x00:
8386             goto op_semantics_55;
8387             break;
8388         }
8389       break;
8390     case 0xc2:
8391         GETBYTE ();
8392         switch (op[1] & 0x00)
8393         {
8394           case 0x00:
8395             goto op_semantics_55;
8396             break;
8397         }
8398       break;
8399     case 0xc3:
8400         GETBYTE ();
8401         switch (op[1] & 0x00)
8402         {
8403           case 0x00:
8404             goto op_semantics_55;
8405             break;
8406         }
8407       break;
8408     case 0xc4:
8409         GETBYTE ();
8410         switch (op[1] & 0x00)
8411         {
8412           case 0x00:
8413             goto op_semantics_55;
8414             break;
8415         }
8416       break;
8417     case 0xc5:
8418         GETBYTE ();
8419         switch (op[1] & 0x00)
8420         {
8421           case 0x00:
8422             goto op_semantics_55;
8423             break;
8424         }
8425       break;
8426     case 0xc6:
8427         GETBYTE ();
8428         switch (op[1] & 0x00)
8429         {
8430           case 0x00:
8431             goto op_semantics_55;
8432             break;
8433         }
8434       break;
8435     case 0xc7:
8436         GETBYTE ();
8437         switch (op[1] & 0x00)
8438         {
8439           case 0x00:
8440             goto op_semantics_55;
8441             break;
8442         }
8443       break;
8444     case 0xc8:
8445         GETBYTE ();
8446         switch (op[1] & 0x00)
8447         {
8448           case 0x00:
8449             goto op_semantics_55;
8450             break;
8451         }
8452       break;
8453     case 0xc9:
8454         GETBYTE ();
8455         switch (op[1] & 0x00)
8456         {
8457           case 0x00:
8458             goto op_semantics_55;
8459             break;
8460         }
8461       break;
8462     case 0xca:
8463         GETBYTE ();
8464         switch (op[1] & 0x00)
8465         {
8466           case 0x00:
8467             goto op_semantics_55;
8468             break;
8469         }
8470       break;
8471     case 0xcb:
8472         GETBYTE ();
8473         switch (op[1] & 0x00)
8474         {
8475           case 0x00:
8476             goto op_semantics_55;
8477             break;
8478         }
8479       break;
8480     case 0xcc:
8481         GETBYTE ();
8482         switch (op[1] & 0x00)
8483         {
8484           case 0x00:
8485             goto op_semantics_55;
8486             break;
8487         }
8488       break;
8489     case 0xcd:
8490         GETBYTE ();
8491         switch (op[1] & 0x00)
8492         {
8493           case 0x00:
8494             goto op_semantics_55;
8495             break;
8496         }
8497       break;
8498     case 0xce:
8499         GETBYTE ();
8500         switch (op[1] & 0x00)
8501         {
8502           case 0x00:
8503             goto op_semantics_55;
8504             break;
8505         }
8506       break;
8507     case 0xcf:
8508         GETBYTE ();
8509         switch (op[1] & 0x00)
8510         {
8511           case 0x00:
8512             goto op_semantics_55;
8513             break;
8514         }
8515       break;
8516     case 0xd0:
8517         GETBYTE ();
8518         switch (op[1] & 0x00)
8519         {
8520           case 0x00:
8521             goto op_semantics_55;
8522             break;
8523         }
8524       break;
8525     case 0xd1:
8526         GETBYTE ();
8527         switch (op[1] & 0x00)
8528         {
8529           case 0x00:
8530             goto op_semantics_55;
8531             break;
8532         }
8533       break;
8534     case 0xd2:
8535         GETBYTE ();
8536         switch (op[1] & 0x00)
8537         {
8538           case 0x00:
8539             goto op_semantics_55;
8540             break;
8541         }
8542       break;
8543     case 0xd3:
8544         GETBYTE ();
8545         switch (op[1] & 0x00)
8546         {
8547           case 0x00:
8548             goto op_semantics_55;
8549             break;
8550         }
8551       break;
8552     case 0xd4:
8553         GETBYTE ();
8554         switch (op[1] & 0x00)
8555         {
8556           case 0x00:
8557             goto op_semantics_55;
8558             break;
8559         }
8560       break;
8561     case 0xd5:
8562         GETBYTE ();
8563         switch (op[1] & 0x00)
8564         {
8565           case 0x00:
8566             goto op_semantics_55;
8567             break;
8568         }
8569       break;
8570     case 0xd6:
8571         GETBYTE ();
8572         switch (op[1] & 0x00)
8573         {
8574           case 0x00:
8575             goto op_semantics_55;
8576             break;
8577         }
8578       break;
8579     case 0xd7:
8580         GETBYTE ();
8581         switch (op[1] & 0x00)
8582         {
8583           case 0x00:
8584             goto op_semantics_55;
8585             break;
8586         }
8587       break;
8588     case 0xd8:
8589         GETBYTE ();
8590         switch (op[1] & 0x00)
8591         {
8592           case 0x00:
8593             goto op_semantics_55;
8594             break;
8595         }
8596       break;
8597     case 0xd9:
8598         GETBYTE ();
8599         switch (op[1] & 0x00)
8600         {
8601           case 0x00:
8602             goto op_semantics_55;
8603             break;
8604         }
8605       break;
8606     case 0xda:
8607         GETBYTE ();
8608         switch (op[1] & 0x00)
8609         {
8610           case 0x00:
8611             goto op_semantics_55;
8612             break;
8613         }
8614       break;
8615     case 0xdb:
8616         GETBYTE ();
8617         switch (op[1] & 0x00)
8618         {
8619           case 0x00:
8620             goto op_semantics_55;
8621             break;
8622         }
8623       break;
8624     case 0xdc:
8625         GETBYTE ();
8626         switch (op[1] & 0x00)
8627         {
8628           case 0x00:
8629             goto op_semantics_55;
8630             break;
8631         }
8632       break;
8633     case 0xdd:
8634         GETBYTE ();
8635         switch (op[1] & 0x00)
8636         {
8637           case 0x00:
8638             goto op_semantics_55;
8639             break;
8640         }
8641       break;
8642     case 0xde:
8643         GETBYTE ();
8644         switch (op[1] & 0x00)
8645         {
8646           case 0x00:
8647             goto op_semantics_55;
8648             break;
8649         }
8650       break;
8651     case 0xdf:
8652         GETBYTE ();
8653         switch (op[1] & 0x00)
8654         {
8655           case 0x00:
8656             goto op_semantics_55;
8657             break;
8658         }
8659       break;
8660     case 0xe0:
8661         GETBYTE ();
8662         switch (op[1] & 0x00)
8663         {
8664           case 0x00:
8665             goto op_semantics_55;
8666             break;
8667         }
8668       break;
8669     case 0xe1:
8670         GETBYTE ();
8671         switch (op[1] & 0x00)
8672         {
8673           case 0x00:
8674             goto op_semantics_55;
8675             break;
8676         }
8677       break;
8678     case 0xe2:
8679         GETBYTE ();
8680         switch (op[1] & 0x00)
8681         {
8682           case 0x00:
8683             goto op_semantics_55;
8684             break;
8685         }
8686       break;
8687     case 0xe3:
8688         GETBYTE ();
8689         switch (op[1] & 0x00)
8690         {
8691           case 0x00:
8692             goto op_semantics_55;
8693             break;
8694         }
8695       break;
8696     case 0xe4:
8697         GETBYTE ();
8698         switch (op[1] & 0x00)
8699         {
8700           case 0x00:
8701             goto op_semantics_55;
8702             break;
8703         }
8704       break;
8705     case 0xe5:
8706         GETBYTE ();
8707         switch (op[1] & 0x00)
8708         {
8709           case 0x00:
8710             goto op_semantics_55;
8711             break;
8712         }
8713       break;
8714     case 0xe6:
8715         GETBYTE ();
8716         switch (op[1] & 0x00)
8717         {
8718           case 0x00:
8719             goto op_semantics_55;
8720             break;
8721         }
8722       break;
8723     case 0xe7:
8724         GETBYTE ();
8725         switch (op[1] & 0x00)
8726         {
8727           case 0x00:
8728             goto op_semantics_55;
8729             break;
8730         }
8731       break;
8732     case 0xe8:
8733         GETBYTE ();
8734         switch (op[1] & 0x00)
8735         {
8736           case 0x00:
8737             goto op_semantics_55;
8738             break;
8739         }
8740       break;
8741     case 0xe9:
8742         GETBYTE ();
8743         switch (op[1] & 0x00)
8744         {
8745           case 0x00:
8746             goto op_semantics_55;
8747             break;
8748         }
8749       break;
8750     case 0xea:
8751         GETBYTE ();
8752         switch (op[1] & 0x00)
8753         {
8754           case 0x00:
8755             goto op_semantics_55;
8756             break;
8757         }
8758       break;
8759     case 0xeb:
8760         GETBYTE ();
8761         switch (op[1] & 0x00)
8762         {
8763           case 0x00:
8764             goto op_semantics_55;
8765             break;
8766         }
8767       break;
8768     case 0xec:
8769         GETBYTE ();
8770         switch (op[1] & 0x00)
8771         {
8772           case 0x00:
8773             goto op_semantics_55;
8774             break;
8775         }
8776       break;
8777     case 0xed:
8778         GETBYTE ();
8779         switch (op[1] & 0x00)
8780         {
8781           case 0x00:
8782             goto op_semantics_55;
8783             break;
8784         }
8785       break;
8786     case 0xee:
8787         GETBYTE ();
8788         switch (op[1] & 0x00)
8789         {
8790           case 0x00:
8791             goto op_semantics_55;
8792             break;
8793         }
8794       break;
8795     case 0xef:
8796         GETBYTE ();
8797         switch (op[1] & 0x00)
8798         {
8799           case 0x00:
8800             goto op_semantics_55;
8801             break;
8802         }
8803       break;
8804     case 0xf0:
8805         GETBYTE ();
8806         switch (op[1] & 0x08)
8807         {
8808           case 0x00:
8809             op_semantics_56:
8810               {
8811                 /** 1111 00sd rdst 0bit                 bset    #%1, %0%S0 */
8812 #line 960 "rx-decode.opc"
8813                 int sd AU = op[0] & 0x03;
8814 #line 960 "rx-decode.opc"
8815                 int rdst AU = (op[1] >> 4) & 0x0f;
8816 #line 960 "rx-decode.opc"
8817                 int bit AU = op[1] & 0x07;
8818                 if (trace)
8819                   {
8820                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8821                            "/** 1111 00sd rdst 0bit                     bset    #%1, %0%S0 */",
8822                            op[0], op[1]);
8823                     printf ("  sd = 0x%x,", sd);
8824                     printf ("  rdst = 0x%x,", rdst);
8825                     printf ("  bit = 0x%x\n", bit);
8826                   }
8827                 SYNTAX("bset    #%1, %0%S0");
8828 #line 960 "rx-decode.opc"
8829                 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8830
8831               }
8832             break;
8833           case 0x08:
8834             op_semantics_57:
8835               {
8836                 /** 1111 00sd rdst 1bit                 bclr    #%1, %0%S0 */
8837 #line 972 "rx-decode.opc"
8838                 int sd AU = op[0] & 0x03;
8839 #line 972 "rx-decode.opc"
8840                 int rdst AU = (op[1] >> 4) & 0x0f;
8841 #line 972 "rx-decode.opc"
8842                 int bit AU = op[1] & 0x07;
8843                 if (trace)
8844                   {
8845                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8846                            "/** 1111 00sd rdst 1bit                     bclr    #%1, %0%S0 */",
8847                            op[0], op[1]);
8848                     printf ("  sd = 0x%x,", sd);
8849                     printf ("  rdst = 0x%x,", rdst);
8850                     printf ("  bit = 0x%x\n", bit);
8851                   }
8852                 SYNTAX("bclr    #%1, %0%S0");
8853 #line 972 "rx-decode.opc"
8854                 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
8855
8856               }
8857             break;
8858         }
8859       break;
8860     case 0xf1:
8861         GETBYTE ();
8862         switch (op[1] & 0x08)
8863         {
8864           case 0x00:
8865             goto op_semantics_56;
8866             break;
8867           case 0x08:
8868             goto op_semantics_57;
8869             break;
8870         }
8871       break;
8872     case 0xf2:
8873         GETBYTE ();
8874         switch (op[1] & 0x08)
8875         {
8876           case 0x00:
8877             goto op_semantics_56;
8878             break;
8879           case 0x08:
8880             goto op_semantics_57;
8881             break;
8882         }
8883       break;
8884     case 0xf3:
8885         GETBYTE ();
8886         switch (op[1] & 0x08)
8887         {
8888           case 0x00:
8889             goto op_semantics_56;
8890             break;
8891           case 0x08:
8892             goto op_semantics_57;
8893             break;
8894         }
8895       break;
8896     case 0xf4:
8897         GETBYTE ();
8898         switch (op[1] & 0x0c)
8899         {
8900           case 0x00:
8901           case 0x04:
8902             op_semantics_58:
8903               {
8904                 /** 1111 01sd rdst 0bit                 btst    #%2, %1%S1 */
8905 #line 984 "rx-decode.opc"
8906                 int sd AU = op[0] & 0x03;
8907 #line 984 "rx-decode.opc"
8908                 int rdst AU = (op[1] >> 4) & 0x0f;
8909 #line 984 "rx-decode.opc"
8910                 int bit AU = op[1] & 0x07;
8911                 if (trace)
8912                   {
8913                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8914                            "/** 1111 01sd rdst 0bit                     btst    #%2, %1%S1 */",
8915                            op[0], op[1]);
8916                     printf ("  sd = 0x%x,", sd);
8917                     printf ("  rdst = 0x%x,", rdst);
8918                     printf ("  bit = 0x%x\n", bit);
8919                   }
8920                 SYNTAX("btst    #%2, %1%S1");
8921 #line 984 "rx-decode.opc"
8922                 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
8923
8924               }
8925             break;
8926           case 0x08:
8927             op_semantics_59:
8928               {
8929                 /** 1111 01ss rsrc 10sz         push%s  %1 */
8930 #line 402 "rx-decode.opc"
8931                 int ss AU = op[0] & 0x03;
8932 #line 402 "rx-decode.opc"
8933                 int rsrc AU = (op[1] >> 4) & 0x0f;
8934 #line 402 "rx-decode.opc"
8935                 int sz AU = op[1] & 0x03;
8936                 if (trace)
8937                   {
8938                     printf ("\033[33m%s\033[0m  %02x %02x\n",
8939                            "/** 1111 01ss rsrc 10sz             push%s  %1 */",
8940                            op[0], op[1]);
8941                     printf ("  ss = 0x%x,", ss);
8942                     printf ("  rsrc = 0x%x,", rsrc);
8943                     printf ("  sz = 0x%x\n", sz);
8944                   }
8945                 SYNTAX("push%s  %1");
8946 #line 402 "rx-decode.opc"
8947                 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____;
8948
8949               /*----------------------------------------------------------------------*/
8950               /* XCHG                                                                   */
8951
8952               }
8953             break;
8954           default: UNSUPPORTED(); break;
8955         }
8956       break;
8957     case 0xf5:
8958         GETBYTE ();
8959         switch (op[1] & 0x0c)
8960         {
8961           case 0x00:
8962           case 0x04:
8963             goto op_semantics_58;
8964             break;
8965           case 0x08:
8966             goto op_semantics_59;
8967             break;
8968           default: UNSUPPORTED(); break;
8969         }
8970       break;
8971     case 0xf6:
8972         GETBYTE ();
8973         switch (op[1] & 0x0c)
8974         {
8975           case 0x00:
8976           case 0x04:
8977             goto op_semantics_58;
8978             break;
8979           case 0x08:
8980             goto op_semantics_59;
8981             break;
8982           default: UNSUPPORTED(); break;
8983         }
8984       break;
8985     case 0xf7:
8986         GETBYTE ();
8987         switch (op[1] & 0x0c)
8988         {
8989           case 0x00:
8990           case 0x04:
8991             goto op_semantics_58;
8992             break;
8993           case 0x08:
8994             goto op_semantics_59;
8995             break;
8996           default: UNSUPPORTED(); break;
8997         }
8998       break;
8999     case 0xf8:
9000         GETBYTE ();
9001         switch (op[1] & 0x00)
9002         {
9003           case 0x00:
9004             op_semantics_60:
9005               {
9006                 /** 1111 10sd rdst im sz        mov%s   #%1, %0 */
9007 #line 313 "rx-decode.opc"
9008                 int sd AU = op[0] & 0x03;
9009 #line 313 "rx-decode.opc"
9010                 int rdst AU = (op[1] >> 4) & 0x0f;
9011 #line 313 "rx-decode.opc"
9012                 int im AU = (op[1] >> 2) & 0x03;
9013 #line 313 "rx-decode.opc"
9014                 int sz AU = op[1] & 0x03;
9015                 if (trace)
9016                   {
9017                     printf ("\033[33m%s\033[0m  %02x %02x\n",
9018                            "/** 1111 10sd rdst im sz    mov%s   #%1, %0 */",
9019                            op[0], op[1]);
9020                     printf ("  sd = 0x%x,", sd);
9021                     printf ("  rdst = 0x%x,", rdst);
9022                     printf ("  im = 0x%x,", im);
9023                     printf ("  sz = 0x%x\n", sz);
9024                   }
9025                 SYNTAX("mov%s   #%1, %0");
9026 #line 313 "rx-decode.opc"
9027                 ID(mov); DD(sd, rdst, sz);
9028                 if ((im == 1 && sz == 0)
9029                     || (im == 2 && sz == 1)
9030                     || (im == 0 && sz == 2))
9031                   {
9032                     BWL (sz);
9033                     SC(IMM(im));
9034                   }
9035                 else
9036                   {
9037                     sBWL (sz);
9038                     SC(IMMex(im));
9039                   }
9040                  F_____;
9041
9042               }
9043             break;
9044         }
9045       break;
9046     case 0xf9:
9047         GETBYTE ();
9048         switch (op[1] & 0xff)
9049         {
9050           case 0x00:
9051           case 0x01:
9052           case 0x02:
9053           case 0x04:
9054           case 0x05:
9055           case 0x06:
9056           case 0x08:
9057           case 0x09:
9058           case 0x0a:
9059           case 0x0c:
9060           case 0x0d:
9061           case 0x0e:
9062           case 0x10:
9063           case 0x11:
9064           case 0x12:
9065           case 0x14:
9066           case 0x15:
9067           case 0x16:
9068           case 0x18:
9069           case 0x19:
9070           case 0x1a:
9071           case 0x1c:
9072           case 0x1d:
9073           case 0x1e:
9074           case 0x20:
9075           case 0x21:
9076           case 0x22:
9077           case 0x24:
9078           case 0x25:
9079           case 0x26:
9080           case 0x28:
9081           case 0x29:
9082           case 0x2a:
9083           case 0x2c:
9084           case 0x2d:
9085           case 0x2e:
9086           case 0x30:
9087           case 0x31:
9088           case 0x32:
9089           case 0x34:
9090           case 0x35:
9091           case 0x36:
9092           case 0x38:
9093           case 0x39:
9094           case 0x3a:
9095           case 0x3c:
9096           case 0x3d:
9097           case 0x3e:
9098           case 0x40:
9099           case 0x41:
9100           case 0x42:
9101           case 0x44:
9102           case 0x45:
9103           case 0x46:
9104           case 0x48:
9105           case 0x49:
9106           case 0x4a:
9107           case 0x4c:
9108           case 0x4d:
9109           case 0x4e:
9110           case 0x50:
9111           case 0x51:
9112           case 0x52:
9113           case 0x54:
9114           case 0x55:
9115           case 0x56:
9116           case 0x58:
9117           case 0x59:
9118           case 0x5a:
9119           case 0x5c:
9120           case 0x5d:
9121           case 0x5e:
9122           case 0x60:
9123           case 0x61:
9124           case 0x62:
9125           case 0x64:
9126           case 0x65:
9127           case 0x66:
9128           case 0x68:
9129           case 0x69:
9130           case 0x6a:
9131           case 0x6c:
9132           case 0x6d:
9133           case 0x6e:
9134           case 0x70:
9135           case 0x71:
9136           case 0x72:
9137           case 0x74:
9138           case 0x75:
9139           case 0x76:
9140           case 0x78:
9141           case 0x79:
9142           case 0x7a:
9143           case 0x7c:
9144           case 0x7d:
9145           case 0x7e:
9146           case 0x80:
9147           case 0x81:
9148           case 0x82:
9149           case 0x84:
9150           case 0x85:
9151           case 0x86:
9152           case 0x88:
9153           case 0x89:
9154           case 0x8a:
9155           case 0x8c:
9156           case 0x8d:
9157           case 0x8e:
9158           case 0x90:
9159           case 0x91:
9160           case 0x92:
9161           case 0x94:
9162           case 0x95:
9163           case 0x96:
9164           case 0x98:
9165           case 0x99:
9166           case 0x9a:
9167           case 0x9c:
9168           case 0x9d:
9169           case 0x9e:
9170           case 0xa0:
9171           case 0xa1:
9172           case 0xa2:
9173           case 0xa4:
9174           case 0xa5:
9175           case 0xa6:
9176           case 0xa8:
9177           case 0xa9:
9178           case 0xaa:
9179           case 0xac:
9180           case 0xad:
9181           case 0xae:
9182           case 0xb0:
9183           case 0xb1:
9184           case 0xb2:
9185           case 0xb4:
9186           case 0xb5:
9187           case 0xb6:
9188           case 0xb8:
9189           case 0xb9:
9190           case 0xba:
9191           case 0xbc:
9192           case 0xbd:
9193           case 0xbe:
9194           case 0xc0:
9195           case 0xc1:
9196           case 0xc2:
9197           case 0xc4:
9198           case 0xc5:
9199           case 0xc6:
9200           case 0xc8:
9201           case 0xc9:
9202           case 0xca:
9203           case 0xcc:
9204           case 0xcd:
9205           case 0xce:
9206           case 0xd0:
9207           case 0xd1:
9208           case 0xd2:
9209           case 0xd4:
9210           case 0xd5:
9211           case 0xd6:
9212           case 0xd8:
9213           case 0xd9:
9214           case 0xda:
9215           case 0xdc:
9216           case 0xdd:
9217           case 0xde:
9218           case 0xe0:
9219           case 0xe1:
9220           case 0xe2:
9221           case 0xe4:
9222           case 0xe5:
9223           case 0xe6:
9224           case 0xe8:
9225           case 0xe9:
9226           case 0xea:
9227           case 0xec:
9228           case 0xed:
9229           case 0xee:
9230           case 0xf0:
9231           case 0xf1:
9232           case 0xf2:
9233           case 0xf4:
9234           case 0xf5:
9235           case 0xf6:
9236           case 0xf8:
9237           case 0xf9:
9238           case 0xfa:
9239           case 0xfc:
9240           case 0xfd:
9241           case 0xfe:
9242             goto op_semantics_60;
9243             break;
9244           case 0x03:
9245               GETBYTE ();
9246               switch (op[2] & 0x0f)
9247               {
9248                 case 0x00:
9249                     {
9250                       /** 1111 1001 0000 0011 rdst 0000 dmov.l  #%1, %0 */
9251 #line 1211 "rx-decode.opc"
9252                       int rdst AU = (op[2] >> 4) & 0x0f;
9253                       if (trace)
9254                         {
9255                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9256                                  "/** 1111 1001 0000 0011 rdst 0000     dmov.l  #%1, %0 */",
9257                                  op[0], op[1], op[2]);
9258                           printf ("  rdst = 0x%x\n", rdst);
9259                         }
9260                       SYNTAX("dmov.l    #%1, %0");
9261 #line 1211 "rx-decode.opc"
9262                       ID(dmov); DDRL(rdst); SC(IMMex(0)); F_____;
9263
9264                     }
9265                   break;
9266                 case 0x02:
9267                 case 0x03:
9268                     {
9269                       /** 1111 1001 0000 0011 rdst 001s dmov%s  #%1, %0 */
9270 #line 1208 "rx-decode.opc"
9271                       int rdst AU = (op[2] >> 4) & 0x0f;
9272 #line 1208 "rx-decode.opc"
9273                       int s AU = op[2] & 0x01;
9274                       if (trace)
9275                         {
9276                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9277                                  "/** 1111 1001 0000 0011 rdst 001s     dmov%s  #%1, %0 */",
9278                                  op[0], op[1], op[2]);
9279                           printf ("  rdst = 0x%x,", rdst);
9280                           printf ("  s = 0x%x\n", s);
9281                         }
9282                       SYNTAX("dmov%s    #%1, %0");
9283 #line 1208 "rx-decode.opc"
9284                       ID(dmov); DDRH(rdst); DL(s); SC(IMMex(0)); F_____;
9285
9286                     }
9287                   break;
9288                 default: UNSUPPORTED(); break;
9289               }
9290             break;
9291           default: UNSUPPORTED(); break;
9292         }
9293       break;
9294     case 0xfa:
9295         GETBYTE ();
9296         switch (op[1] & 0x00)
9297         {
9298           case 0x00:
9299             goto op_semantics_60;
9300             break;
9301         }
9302       break;
9303     case 0xfb:
9304         GETBYTE ();
9305         switch (op[1] & 0x00)
9306         {
9307           case 0x00:
9308             goto op_semantics_60;
9309             break;
9310         }
9311       break;
9312     case 0xfc:
9313         GETBYTE ();
9314         switch (op[1] & 0xff)
9315         {
9316           case 0x03:
9317               GETBYTE ();
9318               switch (op[2] & 0x00)
9319               {
9320                 case 0x00:
9321                     {
9322                       /** 1111 1100 0000 0011 rsrc rdst sbb     %1, %0 */
9323 #line 576 "rx-decode.opc"
9324                       int rsrc AU = (op[2] >> 4) & 0x0f;
9325 #line 576 "rx-decode.opc"
9326                       int rdst AU = op[2] & 0x0f;
9327                       if (trace)
9328                         {
9329                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9330                                  "/** 1111 1100 0000 0011 rsrc rdst     sbb     %1, %0 */",
9331                                  op[0], op[1], op[2]);
9332                           printf ("  rsrc = 0x%x,", rsrc);
9333                           printf ("  rdst = 0x%x\n", rdst);
9334                         }
9335                       SYNTAX("sbb       %1, %0");
9336 #line 576 "rx-decode.opc"
9337                       ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
9338
9339                       /* FIXME: only supports .L */
9340                     }
9341                   break;
9342               }
9343             break;
9344           case 0x07:
9345               GETBYTE ();
9346               switch (op[2] & 0x00)
9347               {
9348                 case 0x00:
9349                     {
9350                       /** 1111 1100 0000 0111 rsrc rdst neg     %2, %0 */
9351 #line 507 "rx-decode.opc"
9352                       int rsrc AU = (op[2] >> 4) & 0x0f;
9353 #line 507 "rx-decode.opc"
9354                       int rdst AU = op[2] & 0x0f;
9355                       if (trace)
9356                         {
9357                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9358                                  "/** 1111 1100 0000 0111 rsrc rdst     neg     %2, %0 */",
9359                                  op[0], op[1], op[2]);
9360                           printf ("  rsrc = 0x%x,", rsrc);
9361                           printf ("  rdst = 0x%x\n", rdst);
9362                         }
9363                       SYNTAX("neg       %2, %0");
9364 #line 507 "rx-decode.opc"
9365                       ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
9366
9367                     /*----------------------------------------------------------------------*/
9368                     /* ADC                                                                      */
9369
9370                     }
9371                   break;
9372               }
9373             break;
9374           case 0x0b:
9375               GETBYTE ();
9376               switch (op[2] & 0x00)
9377               {
9378                 case 0x00:
9379                     {
9380                       /** 1111 1100 0000 1011 rsrc rdst adc     %1, %0 */
9381 #line 516 "rx-decode.opc"
9382                       int rsrc AU = (op[2] >> 4) & 0x0f;
9383 #line 516 "rx-decode.opc"
9384                       int rdst AU = op[2] & 0x0f;
9385                       if (trace)
9386                         {
9387                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9388                                  "/** 1111 1100 0000 1011 rsrc rdst     adc     %1, %0 */",
9389                                  op[0], op[1], op[2]);
9390                           printf ("  rsrc = 0x%x,", rsrc);
9391                           printf ("  rdst = 0x%x\n", rdst);
9392                         }
9393                       SYNTAX("adc       %1, %0");
9394 #line 516 "rx-decode.opc"
9395                       ID(adc); SR(rsrc); DR(rdst); F_OSZC;
9396
9397                     }
9398                   break;
9399               }
9400             break;
9401           case 0x0f:
9402               GETBYTE ();
9403               switch (op[2] & 0x00)
9404               {
9405                 case 0x00:
9406                     {
9407                       /** 1111 1100 0000 1111 rsrc rdst abs     %1, %0 */
9408 #line 589 "rx-decode.opc"
9409                       int rsrc AU = (op[2] >> 4) & 0x0f;
9410 #line 589 "rx-decode.opc"
9411                       int rdst AU = op[2] & 0x0f;
9412                       if (trace)
9413                         {
9414                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9415                                  "/** 1111 1100 0000 1111 rsrc rdst     abs     %1, %0 */",
9416                                  op[0], op[1], op[2]);
9417                           printf ("  rsrc = 0x%x,", rsrc);
9418                           printf ("  rdst = 0x%x\n", rdst);
9419                         }
9420                       SYNTAX("abs       %1, %0");
9421 #line 589 "rx-decode.opc"
9422                       ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
9423
9424                     /*----------------------------------------------------------------------*/
9425                     /* MAX                                                                      */
9426
9427                     }
9428                   break;
9429               }
9430             break;
9431           case 0x10:
9432               GETBYTE ();
9433               switch (op[2] & 0x00)
9434               {
9435                 case 0x00:
9436                   op_semantics_61:
9437                     {
9438                       /** 1111 1100 0001 00ss rsrc rdst max     %1%S1, %0 */
9439 #line 608 "rx-decode.opc"
9440                       int ss AU = op[1] & 0x03;
9441 #line 608 "rx-decode.opc"
9442                       int rsrc AU = (op[2] >> 4) & 0x0f;
9443 #line 608 "rx-decode.opc"
9444                       int rdst AU = op[2] & 0x0f;
9445                       if (trace)
9446                         {
9447                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9448                                  "/** 1111 1100 0001 00ss rsrc rdst     max     %1%S1, %0 */",
9449                                  op[0], op[1], op[2]);
9450                           printf ("  ss = 0x%x,", ss);
9451                           printf ("  rsrc = 0x%x,", rsrc);
9452                           printf ("  rdst = 0x%x\n", rdst);
9453                         }
9454                       SYNTAX("max       %1%S1, %0");
9455 #line 608 "rx-decode.opc"
9456                       if (ss == 3 && rsrc == 0 && rdst == 0)
9457                         {
9458                           ID(nop3);
9459                           SYNTAX("nop\t; max\tr0, r0");
9460                         }
9461                       else
9462                         {
9463                           ID(max); SP(ss, rsrc); DR(rdst);
9464                         }
9465
9466                     }
9467                   break;
9468               }
9469             break;
9470           case 0x11:
9471               GETBYTE ();
9472               switch (op[2] & 0x00)
9473               {
9474                 case 0x00:
9475                   goto op_semantics_61;
9476                   break;
9477               }
9478             break;
9479           case 0x12:
9480               GETBYTE ();
9481               switch (op[2] & 0x00)
9482               {
9483                 case 0x00:
9484                   goto op_semantics_61;
9485                   break;
9486               }
9487             break;
9488           case 0x13:
9489               GETBYTE ();
9490               switch (op[2] & 0x00)
9491               {
9492                 case 0x00:
9493                   goto op_semantics_61;
9494                   break;
9495               }
9496             break;
9497           case 0x14:
9498               GETBYTE ();
9499               switch (op[2] & 0x00)
9500               {
9501                 case 0x00:
9502                   op_semantics_62:
9503                     {
9504                       /** 1111 1100 0001 01ss rsrc rdst min     %1%S1, %0 */
9505 #line 628 "rx-decode.opc"
9506                       int ss AU = op[1] & 0x03;
9507 #line 628 "rx-decode.opc"
9508                       int rsrc AU = (op[2] >> 4) & 0x0f;
9509 #line 628 "rx-decode.opc"
9510                       int rdst AU = op[2] & 0x0f;
9511                       if (trace)
9512                         {
9513                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9514                                  "/** 1111 1100 0001 01ss rsrc rdst     min     %1%S1, %0 */",
9515                                  op[0], op[1], op[2]);
9516                           printf ("  ss = 0x%x,", ss);
9517                           printf ("  rsrc = 0x%x,", rsrc);
9518                           printf ("  rdst = 0x%x\n", rdst);
9519                         }
9520                       SYNTAX("min       %1%S1, %0");
9521 #line 628 "rx-decode.opc"
9522                       ID(min); SP(ss, rsrc); DR(rdst);
9523
9524                     }
9525                   break;
9526               }
9527             break;
9528           case 0x15:
9529               GETBYTE ();
9530               switch (op[2] & 0x00)
9531               {
9532                 case 0x00:
9533                   goto op_semantics_62;
9534                   break;
9535               }
9536             break;
9537           case 0x16:
9538               GETBYTE ();
9539               switch (op[2] & 0x00)
9540               {
9541                 case 0x00:
9542                   goto op_semantics_62;
9543                   break;
9544               }
9545             break;
9546           case 0x17:
9547               GETBYTE ();
9548               switch (op[2] & 0x00)
9549               {
9550                 case 0x00:
9551                   goto op_semantics_62;
9552                   break;
9553               }
9554             break;
9555           case 0x18:
9556               GETBYTE ();
9557               switch (op[2] & 0x00)
9558               {
9559                 case 0x00:
9560                   op_semantics_63:
9561                     {
9562                       /** 1111 1100 0001 10ss rsrc rdst emul    %1%S1, %0 */
9563 #line 686 "rx-decode.opc"
9564                       int ss AU = op[1] & 0x03;
9565 #line 686 "rx-decode.opc"
9566                       int rsrc AU = (op[2] >> 4) & 0x0f;
9567 #line 686 "rx-decode.opc"
9568                       int rdst AU = op[2] & 0x0f;
9569                       if (trace)
9570                         {
9571                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9572                                  "/** 1111 1100 0001 10ss rsrc rdst     emul    %1%S1, %0 */",
9573                                  op[0], op[1], op[2]);
9574                           printf ("  ss = 0x%x,", ss);
9575                           printf ("  rsrc = 0x%x,", rsrc);
9576                           printf ("  rdst = 0x%x\n", rdst);
9577                         }
9578                       SYNTAX("emul      %1%S1, %0");
9579 #line 686 "rx-decode.opc"
9580                       ID(emul); SP(ss, rsrc); DR(rdst);
9581
9582                     }
9583                   break;
9584               }
9585             break;
9586           case 0x19:
9587               GETBYTE ();
9588               switch (op[2] & 0x00)
9589               {
9590                 case 0x00:
9591                   goto op_semantics_63;
9592                   break;
9593               }
9594             break;
9595           case 0x1a:
9596               GETBYTE ();
9597               switch (op[2] & 0x00)
9598               {
9599                 case 0x00:
9600                   goto op_semantics_63;
9601                   break;
9602               }
9603             break;
9604           case 0x1b:
9605               GETBYTE ();
9606               switch (op[2] & 0x00)
9607               {
9608                 case 0x00:
9609                   goto op_semantics_63;
9610                   break;
9611               }
9612             break;
9613           case 0x1c:
9614               GETBYTE ();
9615               switch (op[2] & 0x00)
9616               {
9617                 case 0x00:
9618                   op_semantics_64:
9619                     {
9620                       /** 1111 1100 0001 11ss rsrc rdst emulu   %1%S1, %0 */
9621 #line 698 "rx-decode.opc"
9622                       int ss AU = op[1] & 0x03;
9623 #line 698 "rx-decode.opc"
9624                       int rsrc AU = (op[2] >> 4) & 0x0f;
9625 #line 698 "rx-decode.opc"
9626                       int rdst AU = op[2] & 0x0f;
9627                       if (trace)
9628                         {
9629                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9630                                  "/** 1111 1100 0001 11ss rsrc rdst     emulu   %1%S1, %0 */",
9631                                  op[0], op[1], op[2]);
9632                           printf ("  ss = 0x%x,", ss);
9633                           printf ("  rsrc = 0x%x,", rsrc);
9634                           printf ("  rdst = 0x%x\n", rdst);
9635                         }
9636                       SYNTAX("emulu     %1%S1, %0");
9637 #line 698 "rx-decode.opc"
9638                       ID(emulu); SP(ss, rsrc); DR(rdst);
9639
9640                     }
9641                   break;
9642               }
9643             break;
9644           case 0x1d:
9645               GETBYTE ();
9646               switch (op[2] & 0x00)
9647               {
9648                 case 0x00:
9649                   goto op_semantics_64;
9650                   break;
9651               }
9652             break;
9653           case 0x1e:
9654               GETBYTE ();
9655               switch (op[2] & 0x00)
9656               {
9657                 case 0x00:
9658                   goto op_semantics_64;
9659                   break;
9660               }
9661             break;
9662           case 0x1f:
9663               GETBYTE ();
9664               switch (op[2] & 0x00)
9665               {
9666                 case 0x00:
9667                   goto op_semantics_64;
9668                   break;
9669               }
9670             break;
9671           case 0x20:
9672               GETBYTE ();
9673               switch (op[2] & 0x00)
9674               {
9675                 case 0x00:
9676                   op_semantics_65:
9677                     {
9678                       /** 1111 1100 0010 00ss rsrc rdst div     %1%S1, %0 */
9679 #line 710 "rx-decode.opc"
9680                       int ss AU = op[1] & 0x03;
9681 #line 710 "rx-decode.opc"
9682                       int rsrc AU = (op[2] >> 4) & 0x0f;
9683 #line 710 "rx-decode.opc"
9684                       int rdst AU = op[2] & 0x0f;
9685                       if (trace)
9686                         {
9687                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9688                                  "/** 1111 1100 0010 00ss rsrc rdst     div     %1%S1, %0 */",
9689                                  op[0], op[1], op[2]);
9690                           printf ("  ss = 0x%x,", ss);
9691                           printf ("  rsrc = 0x%x,", rsrc);
9692                           printf ("  rdst = 0x%x\n", rdst);
9693                         }
9694                       SYNTAX("div       %1%S1, %0");
9695 #line 710 "rx-decode.opc"
9696                       ID(div); SP(ss, rsrc); DR(rdst); F_O___;
9697
9698                     }
9699                   break;
9700               }
9701             break;
9702           case 0x21:
9703               GETBYTE ();
9704               switch (op[2] & 0x00)
9705               {
9706                 case 0x00:
9707                   goto op_semantics_65;
9708                   break;
9709               }
9710             break;
9711           case 0x22:
9712               GETBYTE ();
9713               switch (op[2] & 0x00)
9714               {
9715                 case 0x00:
9716                   goto op_semantics_65;
9717                   break;
9718               }
9719             break;
9720           case 0x23:
9721               GETBYTE ();
9722               switch (op[2] & 0x00)
9723               {
9724                 case 0x00:
9725                   goto op_semantics_65;
9726                   break;
9727               }
9728             break;
9729           case 0x24:
9730               GETBYTE ();
9731               switch (op[2] & 0x00)
9732               {
9733                 case 0x00:
9734                   op_semantics_66:
9735                     {
9736                       /** 1111 1100 0010 01ss rsrc rdst divu    %1%S1, %0 */
9737 #line 722 "rx-decode.opc"
9738                       int ss AU = op[1] & 0x03;
9739 #line 722 "rx-decode.opc"
9740                       int rsrc AU = (op[2] >> 4) & 0x0f;
9741 #line 722 "rx-decode.opc"
9742                       int rdst AU = op[2] & 0x0f;
9743                       if (trace)
9744                         {
9745                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9746                                  "/** 1111 1100 0010 01ss rsrc rdst     divu    %1%S1, %0 */",
9747                                  op[0], op[1], op[2]);
9748                           printf ("  ss = 0x%x,", ss);
9749                           printf ("  rsrc = 0x%x,", rsrc);
9750                           printf ("  rdst = 0x%x\n", rdst);
9751                         }
9752                       SYNTAX("divu      %1%S1, %0");
9753 #line 722 "rx-decode.opc"
9754                       ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
9755
9756                     }
9757                   break;
9758               }
9759             break;
9760           case 0x25:
9761               GETBYTE ();
9762               switch (op[2] & 0x00)
9763               {
9764                 case 0x00:
9765                   goto op_semantics_66;
9766                   break;
9767               }
9768             break;
9769           case 0x26:
9770               GETBYTE ();
9771               switch (op[2] & 0x00)
9772               {
9773                 case 0x00:
9774                   goto op_semantics_66;
9775                   break;
9776               }
9777             break;
9778           case 0x27:
9779               GETBYTE ();
9780               switch (op[2] & 0x00)
9781               {
9782                 case 0x00:
9783                   goto op_semantics_66;
9784                   break;
9785               }
9786             break;
9787           case 0x30:
9788               GETBYTE ();
9789               switch (op[2] & 0x00)
9790               {
9791                 case 0x00:
9792                   op_semantics_67:
9793                     {
9794                       /** 1111 1100 0011 00ss rsrc rdst tst     %1%S1, %2 */
9795 #line 495 "rx-decode.opc"
9796                       int ss AU = op[1] & 0x03;
9797 #line 495 "rx-decode.opc"
9798                       int rsrc AU = (op[2] >> 4) & 0x0f;
9799 #line 495 "rx-decode.opc"
9800                       int rdst AU = op[2] & 0x0f;
9801                       if (trace)
9802                         {
9803                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9804                                  "/** 1111 1100 0011 00ss rsrc rdst     tst     %1%S1, %2 */",
9805                                  op[0], op[1], op[2]);
9806                           printf ("  ss = 0x%x,", ss);
9807                           printf ("  rsrc = 0x%x,", rsrc);
9808                           printf ("  rdst = 0x%x\n", rdst);
9809                         }
9810                       SYNTAX("tst       %1%S1, %2");
9811 #line 495 "rx-decode.opc"
9812                       ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
9813
9814                     }
9815                   break;
9816               }
9817             break;
9818           case 0x31:
9819               GETBYTE ();
9820               switch (op[2] & 0x00)
9821               {
9822                 case 0x00:
9823                   goto op_semantics_67;
9824                   break;
9825               }
9826             break;
9827           case 0x32:
9828               GETBYTE ();
9829               switch (op[2] & 0x00)
9830               {
9831                 case 0x00:
9832                   goto op_semantics_67;
9833                   break;
9834               }
9835             break;
9836           case 0x33:
9837               GETBYTE ();
9838               switch (op[2] & 0x00)
9839               {
9840                 case 0x00:
9841                   goto op_semantics_67;
9842                   break;
9843               }
9844             break;
9845           case 0x34:
9846               GETBYTE ();
9847               switch (op[2] & 0x00)
9848               {
9849                 case 0x00:
9850                   op_semantics_68:
9851                     {
9852                       /** 1111 1100 0011 01ss rsrc rdst xor     %1%S1, %0 */
9853 #line 474 "rx-decode.opc"
9854                       int ss AU = op[1] & 0x03;
9855 #line 474 "rx-decode.opc"
9856                       int rsrc AU = (op[2] >> 4) & 0x0f;
9857 #line 474 "rx-decode.opc"
9858                       int rdst AU = op[2] & 0x0f;
9859                       if (trace)
9860                         {
9861                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9862                                  "/** 1111 1100 0011 01ss rsrc rdst     xor     %1%S1, %0 */",
9863                                  op[0], op[1], op[2]);
9864                           printf ("  ss = 0x%x,", ss);
9865                           printf ("  rsrc = 0x%x,", rsrc);
9866                           printf ("  rdst = 0x%x\n", rdst);
9867                         }
9868                       SYNTAX("xor       %1%S1, %0");
9869 #line 474 "rx-decode.opc"
9870                       ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
9871
9872                     }
9873                   break;
9874               }
9875             break;
9876           case 0x35:
9877               GETBYTE ();
9878               switch (op[2] & 0x00)
9879               {
9880                 case 0x00:
9881                   goto op_semantics_68;
9882                   break;
9883               }
9884             break;
9885           case 0x36:
9886               GETBYTE ();
9887               switch (op[2] & 0x00)
9888               {
9889                 case 0x00:
9890                   goto op_semantics_68;
9891                   break;
9892               }
9893             break;
9894           case 0x37:
9895               GETBYTE ();
9896               switch (op[2] & 0x00)
9897               {
9898                 case 0x00:
9899                   goto op_semantics_68;
9900                   break;
9901               }
9902             break;
9903           case 0x3b:
9904               GETBYTE ();
9905               switch (op[2] & 0x00)
9906               {
9907                 case 0x00:
9908                     {
9909                       /** 1111 1100 0011 1011 rsrc rdst not     %1, %0 */
9910 #line 486 "rx-decode.opc"
9911                       int rsrc AU = (op[2] >> 4) & 0x0f;
9912 #line 486 "rx-decode.opc"
9913                       int rdst AU = op[2] & 0x0f;
9914                       if (trace)
9915                         {
9916                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9917                                  "/** 1111 1100 0011 1011 rsrc rdst     not     %1, %0 */",
9918                                  op[0], op[1], op[2]);
9919                           printf ("  rsrc = 0x%x,", rsrc);
9920                           printf ("  rdst = 0x%x\n", rdst);
9921                         }
9922                       SYNTAX("not       %1, %0");
9923 #line 486 "rx-decode.opc"
9924                       ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
9925
9926                     /*----------------------------------------------------------------------*/
9927                     /* TST                                                                      */
9928
9929                     }
9930                   break;
9931               }
9932             break;
9933           case 0x40:
9934               GETBYTE ();
9935               switch (op[2] & 0x00)
9936               {
9937                 case 0x00:
9938                   op_semantics_69:
9939                     {
9940                       /** 1111 1100 0100 00ss rsrc rdst xchg    %1%S1, %0 */
9941 #line 408 "rx-decode.opc"
9942                       int ss AU = op[1] & 0x03;
9943 #line 408 "rx-decode.opc"
9944                       int rsrc AU = (op[2] >> 4) & 0x0f;
9945 #line 408 "rx-decode.opc"
9946                       int rdst AU = op[2] & 0x0f;
9947                       if (trace)
9948                         {
9949                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
9950                                  "/** 1111 1100 0100 00ss rsrc rdst     xchg    %1%S1, %0 */",
9951                                  op[0], op[1], op[2]);
9952                           printf ("  ss = 0x%x,", ss);
9953                           printf ("  rsrc = 0x%x,", rsrc);
9954                           printf ("  rdst = 0x%x\n", rdst);
9955                         }
9956                       SYNTAX("xchg      %1%S1, %0");
9957 #line 408 "rx-decode.opc"
9958                       ID(xchg); DR(rdst); SP(ss, rsrc);
9959
9960                     }
9961                   break;
9962               }
9963             break;
9964           case 0x41:
9965               GETBYTE ();
9966               switch (op[2] & 0x00)
9967               {
9968                 case 0x00:
9969                   goto op_semantics_69;
9970                   break;
9971               }
9972             break;
9973           case 0x42:
9974               GETBYTE ();
9975               switch (op[2] & 0x00)
9976               {
9977                 case 0x00:
9978                   goto op_semantics_69;
9979                   break;
9980               }
9981             break;
9982           case 0x43:
9983               GETBYTE ();
9984               switch (op[2] & 0x00)
9985               {
9986                 case 0x00:
9987                   goto op_semantics_69;
9988                   break;
9989               }
9990             break;
9991           case 0x44:
9992               GETBYTE ();
9993               switch (op[2] & 0x00)
9994               {
9995                 case 0x00:
9996                   op_semantics_70:
9997                     {
9998                       /** 1111 1100 0100 01sd rsrc rdst itof    %1%S1, %0 */
9999 #line 951 "rx-decode.opc"
10000                       int sd AU = op[1] & 0x03;
10001 #line 951 "rx-decode.opc"
10002                       int rsrc AU = (op[2] >> 4) & 0x0f;
10003 #line 951 "rx-decode.opc"
10004                       int rdst AU = op[2] & 0x0f;
10005                       if (trace)
10006                         {
10007                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10008                                  "/** 1111 1100 0100 01sd rsrc rdst     itof    %1%S1, %0 */",
10009                                  op[0], op[1], op[2]);
10010                           printf ("  sd = 0x%x,", sd);
10011                           printf ("  rsrc = 0x%x,", rsrc);
10012                           printf ("  rdst = 0x%x\n", rdst);
10013                         }
10014                       SYNTAX("itof      %1%S1, %0");
10015 #line 951 "rx-decode.opc"
10016                       ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
10017
10018                     }
10019                   break;
10020               }
10021             break;
10022           case 0x45:
10023               GETBYTE ();
10024               switch (op[2] & 0x00)
10025               {
10026                 case 0x00:
10027                   goto op_semantics_70;
10028                   break;
10029               }
10030             break;
10031           case 0x46:
10032               GETBYTE ();
10033               switch (op[2] & 0x00)
10034               {
10035                 case 0x00:
10036                   goto op_semantics_70;
10037                   break;
10038               }
10039             break;
10040           case 0x47:
10041               GETBYTE ();
10042               switch (op[2] & 0x00)
10043               {
10044                 case 0x00:
10045                   goto op_semantics_70;
10046                   break;
10047               }
10048             break;
10049           case 0x4b:
10050               GETBYTE ();
10051               switch (op[2] & 0x00)
10052               {
10053                 case 0x00:
10054                     {
10055                       /** 1111 1100 0100 1011 rsrc rdst stz     %1, %0 */
10056 #line 1077 "rx-decode.opc"
10057                       int rsrc AU = (op[2] >> 4) & 0x0f;
10058 #line 1077 "rx-decode.opc"
10059                       int rdst AU = op[2] & 0x0f;
10060                       if (trace)
10061                         {
10062                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10063                                  "/** 1111 1100 0100 1011 rsrc rdst     stz     %1, %0 */",
10064                                  op[0], op[1], op[2]);
10065                           printf ("  rsrc = 0x%x,", rsrc);
10066                           printf ("  rdst = 0x%x\n", rdst);
10067                         }
10068                       SYNTAX("stz       %1, %0");
10069 #line 1077 "rx-decode.opc"
10070                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_z);
10071
10072                     }
10073                   break;
10074               }
10075             break;
10076           case 0x4f:
10077               GETBYTE ();
10078               switch (op[2] & 0x00)
10079               {
10080                 case 0x00:
10081                     {
10082                       /** 1111 1100 0100 1111 rsrc rdst stnz    %1, %0 */
10083 #line 1080 "rx-decode.opc"
10084                       int rsrc AU = (op[2] >> 4) & 0x0f;
10085 #line 1080 "rx-decode.opc"
10086                       int rdst AU = op[2] & 0x0f;
10087                       if (trace)
10088                         {
10089                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10090                                  "/** 1111 1100 0100 1111 rsrc rdst     stnz    %1, %0 */",
10091                                  op[0], op[1], op[2]);
10092                           printf ("  rsrc = 0x%x,", rsrc);
10093                           printf ("  rdst = 0x%x\n", rdst);
10094                         }
10095                       SYNTAX("stnz      %1, %0");
10096 #line 1080 "rx-decode.opc"
10097                       ID(stcc); SR(rsrc); DR(rdst); S2cc(RXC_nz);
10098
10099                     }
10100                   break;
10101               }
10102             break;
10103           case 0x54:
10104               GETBYTE ();
10105               switch (op[2] & 0x00)
10106               {
10107                 case 0x00:
10108                   op_semantics_71:
10109                     {
10110                       /** 1111 1100 0101 01sd rsrc rdst utof    %1%S1, %0 */
10111 #line 1137 "rx-decode.opc"
10112                       int sd AU = op[1] & 0x03;
10113 #line 1137 "rx-decode.opc"
10114                       int rsrc AU = (op[2] >> 4) & 0x0f;
10115 #line 1137 "rx-decode.opc"
10116                       int rdst AU = op[2] & 0x0f;
10117                       if (trace)
10118                         {
10119                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10120                                  "/** 1111 1100 0101 01sd rsrc rdst     utof    %1%S1, %0 */",
10121                                  op[0], op[1], op[2]);
10122                           printf ("  sd = 0x%x,", sd);
10123                           printf ("  rsrc = 0x%x,", rsrc);
10124                           printf ("  rdst = 0x%x\n", rdst);
10125                         }
10126                       SYNTAX("utof      %1%S1, %0");
10127 #line 1137 "rx-decode.opc"
10128                       ID(utof); DR (rdst); SP(sd, rsrc); F__SZ_;
10129
10130                     }
10131                   break;
10132               }
10133             break;
10134           case 0x55:
10135               GETBYTE ();
10136               switch (op[2] & 0x00)
10137               {
10138                 case 0x00:
10139                   goto op_semantics_71;
10140                   break;
10141               }
10142             break;
10143           case 0x56:
10144               GETBYTE ();
10145               switch (op[2] & 0x00)
10146               {
10147                 case 0x00:
10148                   goto op_semantics_71;
10149                   break;
10150               }
10151             break;
10152           case 0x57:
10153               GETBYTE ();
10154               switch (op[2] & 0x00)
10155               {
10156                 case 0x00:
10157                   goto op_semantics_71;
10158                   break;
10159               }
10160             break;
10161           case 0x5a:
10162               GETBYTE ();
10163               switch (op[2] & 0x00)
10164               {
10165                 case 0x00:
10166                     {
10167                       /** 1111 1100 0101 1010 rsrc rdst bfmovz  %bf */
10168 #line 1152 "rx-decode.opc"
10169                       int rsrc AU = (op[2] >> 4) & 0x0f;
10170 #line 1152 "rx-decode.opc"
10171                       int rdst AU = op[2] & 0x0f;
10172                       if (trace)
10173                         {
10174                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10175                                  "/** 1111 1100 0101 1010 rsrc rdst     bfmovz  %bf */",
10176                                  op[0], op[1], op[2]);
10177                           printf ("  rsrc = 0x%x,", rsrc);
10178                           printf ("  rdst = 0x%x\n", rdst);
10179                         }
10180                       SYNTAX("bfmovz    %bf");
10181 #line 1152 "rx-decode.opc"
10182                       ID(bfmovz); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10183
10184                     }
10185                   break;
10186               }
10187             break;
10188           case 0x5e:
10189               GETBYTE ();
10190               switch (op[2] & 0x00)
10191               {
10192                 case 0x00:
10193                     {
10194                       /** 1111 1100 0101 1110 rsrc rdst bfmov   %bf */
10195 #line 1149 "rx-decode.opc"
10196                       int rsrc AU = (op[2] >> 4) & 0x0f;
10197 #line 1149 "rx-decode.opc"
10198                       int rdst AU = op[2] & 0x0f;
10199                       if (trace)
10200                         {
10201                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10202                                  "/** 1111 1100 0101 1110 rsrc rdst     bfmov   %bf */",
10203                                  op[0], op[1], op[2]);
10204                           printf ("  rsrc = 0x%x,", rsrc);
10205                           printf ("  rdst = 0x%x\n", rdst);
10206                         }
10207                       SYNTAX("bfmov     %bf");
10208 #line 1149 "rx-decode.opc"
10209                       ID(bfmov); DR(rdst); SR(rsrc); S2C(IMM(2)); F_____;
10210
10211                     }
10212                   break;
10213               }
10214             break;
10215           case 0x60:
10216               GETBYTE ();
10217               switch (op[2] & 0x00)
10218               {
10219                 case 0x00:
10220                   op_semantics_72:
10221                     {
10222                       /** 1111 1100 0110 00sd rdst rsrc bset    %1, %0%S0 */
10223 #line 963 "rx-decode.opc"
10224                       int sd AU = op[1] & 0x03;
10225 #line 963 "rx-decode.opc"
10226                       int rdst AU = (op[2] >> 4) & 0x0f;
10227 #line 963 "rx-decode.opc"
10228                       int rsrc AU = op[2] & 0x0f;
10229                       if (trace)
10230                         {
10231                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10232                                  "/** 1111 1100 0110 00sd rdst rsrc     bset    %1, %0%S0 */",
10233                                  op[0], op[1], op[2]);
10234                           printf ("  sd = 0x%x,", sd);
10235                           printf ("  rdst = 0x%x,", rdst);
10236                           printf ("  rsrc = 0x%x\n", rsrc);
10237                         }
10238                       SYNTAX("bset      %1, %0%S0");
10239 #line 963 "rx-decode.opc"
10240                       ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10241                       if (sd == 3) /* bset reg,reg */
10242                         BWL(LSIZE);
10243
10244                     }
10245                   break;
10246               }
10247             break;
10248           case 0x61:
10249               GETBYTE ();
10250               switch (op[2] & 0x00)
10251               {
10252                 case 0x00:
10253                   goto op_semantics_72;
10254                   break;
10255               }
10256             break;
10257           case 0x62:
10258               GETBYTE ();
10259               switch (op[2] & 0x00)
10260               {
10261                 case 0x00:
10262                   goto op_semantics_72;
10263                   break;
10264               }
10265             break;
10266           case 0x63:
10267               GETBYTE ();
10268               switch (op[2] & 0x00)
10269               {
10270                 case 0x00:
10271                   goto op_semantics_72;
10272                   break;
10273               }
10274             break;
10275           case 0x64:
10276               GETBYTE ();
10277               switch (op[2] & 0x00)
10278               {
10279                 case 0x00:
10280                   op_semantics_73:
10281                     {
10282                       /** 1111 1100 0110 01sd rdst rsrc bclr    %1, %0%S0 */
10283 #line 975 "rx-decode.opc"
10284                       int sd AU = op[1] & 0x03;
10285 #line 975 "rx-decode.opc"
10286                       int rdst AU = (op[2] >> 4) & 0x0f;
10287 #line 975 "rx-decode.opc"
10288                       int rsrc AU = op[2] & 0x0f;
10289                       if (trace)
10290                         {
10291                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10292                                  "/** 1111 1100 0110 01sd rdst rsrc     bclr    %1, %0%S0 */",
10293                                  op[0], op[1], op[2]);
10294                           printf ("  sd = 0x%x,", sd);
10295                           printf ("  rdst = 0x%x,", rdst);
10296                           printf ("  rsrc = 0x%x\n", rsrc);
10297                         }
10298                       SYNTAX("bclr      %1, %0%S0");
10299 #line 975 "rx-decode.opc"
10300                       ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
10301                       if (sd == 3) /* bset reg,reg */
10302                         BWL(LSIZE);
10303
10304                     }
10305                   break;
10306               }
10307             break;
10308           case 0x65:
10309               GETBYTE ();
10310               switch (op[2] & 0x00)
10311               {
10312                 case 0x00:
10313                   goto op_semantics_73;
10314                   break;
10315               }
10316             break;
10317           case 0x66:
10318               GETBYTE ();
10319               switch (op[2] & 0x00)
10320               {
10321                 case 0x00:
10322                   goto op_semantics_73;
10323                   break;
10324               }
10325             break;
10326           case 0x67:
10327               GETBYTE ();
10328               switch (op[2] & 0x00)
10329               {
10330                 case 0x00:
10331                   goto op_semantics_73;
10332                   break;
10333               }
10334             break;
10335           case 0x68:
10336               GETBYTE ();
10337               switch (op[2] & 0x00)
10338               {
10339                 case 0x00:
10340                   op_semantics_74:
10341                     {
10342                       /** 1111 1100 0110 10sd rdst rsrc btst    %2, %1%S1 */
10343 #line 987 "rx-decode.opc"
10344                       int sd AU = op[1] & 0x03;
10345 #line 987 "rx-decode.opc"
10346                       int rdst AU = (op[2] >> 4) & 0x0f;
10347 #line 987 "rx-decode.opc"
10348                       int rsrc AU = op[2] & 0x0f;
10349                       if (trace)
10350                         {
10351                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10352                                  "/** 1111 1100 0110 10sd rdst rsrc     btst    %2, %1%S1 */",
10353                                  op[0], op[1], op[2]);
10354                           printf ("  sd = 0x%x,", sd);
10355                           printf ("  rdst = 0x%x,", rdst);
10356                           printf ("  rsrc = 0x%x\n", rsrc);
10357                         }
10358                       SYNTAX("btst      %2, %1%S1");
10359 #line 987 "rx-decode.opc"
10360                       ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
10361                       if (sd == 3) /* bset reg,reg */
10362                         BWL(LSIZE);
10363
10364                     }
10365                   break;
10366               }
10367             break;
10368           case 0x69:
10369               GETBYTE ();
10370               switch (op[2] & 0x00)
10371               {
10372                 case 0x00:
10373                   goto op_semantics_74;
10374                   break;
10375               }
10376             break;
10377           case 0x6a:
10378               GETBYTE ();
10379               switch (op[2] & 0x00)
10380               {
10381                 case 0x00:
10382                   goto op_semantics_74;
10383                   break;
10384               }
10385             break;
10386           case 0x6b:
10387               GETBYTE ();
10388               switch (op[2] & 0x00)
10389               {
10390                 case 0x00:
10391                   goto op_semantics_74;
10392                   break;
10393               }
10394             break;
10395           case 0x6c:
10396               GETBYTE ();
10397               switch (op[2] & 0x00)
10398               {
10399                 case 0x00:
10400                   op_semantics_75:
10401                     {
10402                       /** 1111 1100 0110 11sd rdst rsrc bnot    %1, %0%S0 */
10403 #line 999 "rx-decode.opc"
10404                       int sd AU = op[1] & 0x03;
10405 #line 999 "rx-decode.opc"
10406                       int rdst AU = (op[2] >> 4) & 0x0f;
10407 #line 999 "rx-decode.opc"
10408                       int rsrc AU = op[2] & 0x0f;
10409                       if (trace)
10410                         {
10411                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10412                                  "/** 1111 1100 0110 11sd rdst rsrc     bnot    %1, %0%S0 */",
10413                                  op[0], op[1], op[2]);
10414                           printf ("  sd = 0x%x,", sd);
10415                           printf ("  rdst = 0x%x,", rdst);
10416                           printf ("  rsrc = 0x%x\n", rsrc);
10417                         }
10418                       SYNTAX("bnot      %1, %0%S0");
10419 #line 999 "rx-decode.opc"
10420                       ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
10421                       if (sd == 3) /* bset reg,reg */
10422                         BWL(LSIZE);
10423
10424                     }
10425                   break;
10426               }
10427             break;
10428           case 0x6d:
10429               GETBYTE ();
10430               switch (op[2] & 0x00)
10431               {
10432                 case 0x00:
10433                   goto op_semantics_75;
10434                   break;
10435               }
10436             break;
10437           case 0x6e:
10438               GETBYTE ();
10439               switch (op[2] & 0x00)
10440               {
10441                 case 0x00:
10442                   goto op_semantics_75;
10443                   break;
10444               }
10445             break;
10446           case 0x6f:
10447               GETBYTE ();
10448               switch (op[2] & 0x00)
10449               {
10450                 case 0x00:
10451                   goto op_semantics_75;
10452                   break;
10453               }
10454             break;
10455           case 0x78:
10456               GETBYTE ();
10457               switch (op[2] & 0x0f)
10458               {
10459                 case 0x08:
10460                   op_semantics_76:
10461                     {
10462                       /** 1111 1100 0111 10sz rdst 1000 dmov.d  %1, %0 */
10463 #line 1185 "rx-decode.opc"
10464                       int sz AU = op[1] & 0x03;
10465 #line 1185 "rx-decode.opc"
10466                       int rdst AU = (op[2] >> 4) & 0x0f;
10467                       if (trace)
10468                         {
10469                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10470                                  "/** 1111 1100 0111 10sz rdst 1000     dmov.d  %1, %0 */",
10471                                  op[0], op[1], op[2]);
10472                           printf ("  sz = 0x%x,", sz);
10473                           printf ("  rdst = 0x%x\n", rdst);
10474                         }
10475                       SYNTAX("dmov.d    %1, %0");
10476 #line 1185 "rx-decode.opc"
10477                       int rsrc;
10478                       rx_disp(0, sz, rdst, RX_Double, ld);
10479                       rsrc = GETBYTE();
10480                       if (rsrc & 0x0f)
10481                         UNSUPPORTED();
10482                       else {
10483                         ID(dmov); SDR(rsrc >> 4); F_____;
10484                       }
10485
10486                     }
10487                   break;
10488                 default: UNSUPPORTED(); break;
10489               }
10490             break;
10491           case 0x79:
10492               GETBYTE ();
10493               switch (op[2] & 0x0f)
10494               {
10495                 case 0x08:
10496                   goto op_semantics_76;
10497                   break;
10498                 default: UNSUPPORTED(); break;
10499               }
10500             break;
10501           case 0x7a:
10502               GETBYTE ();
10503               switch (op[2] & 0x0f)
10504               {
10505                 case 0x08:
10506                   goto op_semantics_76;
10507                   break;
10508                 default: UNSUPPORTED(); break;
10509               }
10510             break;
10511           case 0x80:
10512               GETBYTE ();
10513               switch (op[2] & 0x00)
10514               {
10515                 case 0x00:
10516                   op_semantics_77:
10517                     {
10518                       /** 1111 1100 1000 00sd rsrc rdst fsub    %1%S1, %0 */
10519 #line 930 "rx-decode.opc"
10520                       int sd AU = op[1] & 0x03;
10521 #line 930 "rx-decode.opc"
10522                       int rsrc AU = (op[2] >> 4) & 0x0f;
10523 #line 930 "rx-decode.opc"
10524                       int rdst AU = op[2] & 0x0f;
10525                       if (trace)
10526                         {
10527                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10528                                  "/** 1111 1100 1000 00sd rsrc rdst     fsub    %1%S1, %0 */",
10529                                  op[0], op[1], op[2]);
10530                           printf ("  sd = 0x%x,", sd);
10531                           printf ("  rsrc = 0x%x,", rsrc);
10532                           printf ("  rdst = 0x%x\n", rdst);
10533                         }
10534                       SYNTAX("fsub      %1%S1, %0");
10535 #line 930 "rx-decode.opc"
10536                       ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10537
10538                     }
10539                   break;
10540               }
10541             break;
10542           case 0x81:
10543               GETBYTE ();
10544               switch (op[2] & 0x00)
10545               {
10546                 case 0x00:
10547                   goto op_semantics_77;
10548                   break;
10549               }
10550             break;
10551           case 0x82:
10552               GETBYTE ();
10553               switch (op[2] & 0x00)
10554               {
10555                 case 0x00:
10556                   goto op_semantics_77;
10557                   break;
10558               }
10559             break;
10560           case 0x83:
10561               GETBYTE ();
10562               switch (op[2] & 0x00)
10563               {
10564                 case 0x00:
10565                   goto op_semantics_77;
10566                   break;
10567               }
10568             break;
10569           case 0x84:
10570               GETBYTE ();
10571               switch (op[2] & 0x00)
10572               {
10573                 case 0x00:
10574                   op_semantics_78:
10575                     {
10576                       /** 1111 1100 1000 01sd rsrc rdst fcmp    %1%S1, %0 */
10577 #line 924 "rx-decode.opc"
10578                       int sd AU = op[1] & 0x03;
10579 #line 924 "rx-decode.opc"
10580                       int rsrc AU = (op[2] >> 4) & 0x0f;
10581 #line 924 "rx-decode.opc"
10582                       int rdst AU = op[2] & 0x0f;
10583                       if (trace)
10584                         {
10585                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10586                                  "/** 1111 1100 1000 01sd rsrc rdst     fcmp    %1%S1, %0 */",
10587                                  op[0], op[1], op[2]);
10588                           printf ("  sd = 0x%x,", sd);
10589                           printf ("  rsrc = 0x%x,", rsrc);
10590                           printf ("  rdst = 0x%x\n", rdst);
10591                         }
10592                       SYNTAX("fcmp      %1%S1, %0");
10593 #line 924 "rx-decode.opc"
10594                       ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
10595
10596                     }
10597                   break;
10598               }
10599             break;
10600           case 0x85:
10601               GETBYTE ();
10602               switch (op[2] & 0x00)
10603               {
10604                 case 0x00:
10605                   goto op_semantics_78;
10606                   break;
10607               }
10608             break;
10609           case 0x86:
10610               GETBYTE ();
10611               switch (op[2] & 0x00)
10612               {
10613                 case 0x00:
10614                   goto op_semantics_78;
10615                   break;
10616               }
10617             break;
10618           case 0x87:
10619               GETBYTE ();
10620               switch (op[2] & 0x00)
10621               {
10622                 case 0x00:
10623                   goto op_semantics_78;
10624                   break;
10625               }
10626             break;
10627           case 0x88:
10628               GETBYTE ();
10629               switch (op[2] & 0x00)
10630               {
10631                 case 0x00:
10632                   op_semantics_79:
10633                     {
10634                       /** 1111 1100 1000 10sd rsrc rdst fadd    %1%S1, %0 */
10635 #line 918 "rx-decode.opc"
10636                       int sd AU = op[1] & 0x03;
10637 #line 918 "rx-decode.opc"
10638                       int rsrc AU = (op[2] >> 4) & 0x0f;
10639 #line 918 "rx-decode.opc"
10640                       int rdst AU = op[2] & 0x0f;
10641                       if (trace)
10642                         {
10643                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10644                                  "/** 1111 1100 1000 10sd rsrc rdst     fadd    %1%S1, %0 */",
10645                                  op[0], op[1], op[2]);
10646                           printf ("  sd = 0x%x,", sd);
10647                           printf ("  rsrc = 0x%x,", rsrc);
10648                           printf ("  rdst = 0x%x\n", rdst);
10649                         }
10650                       SYNTAX("fadd      %1%S1, %0");
10651 #line 918 "rx-decode.opc"
10652                       ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10653
10654                     }
10655                   break;
10656               }
10657             break;
10658           case 0x89:
10659               GETBYTE ();
10660               switch (op[2] & 0x00)
10661               {
10662                 case 0x00:
10663                   goto op_semantics_79;
10664                   break;
10665               }
10666             break;
10667           case 0x8a:
10668               GETBYTE ();
10669               switch (op[2] & 0x00)
10670               {
10671                 case 0x00:
10672                   goto op_semantics_79;
10673                   break;
10674               }
10675             break;
10676           case 0x8b:
10677               GETBYTE ();
10678               switch (op[2] & 0x00)
10679               {
10680                 case 0x00:
10681                   goto op_semantics_79;
10682                   break;
10683               }
10684             break;
10685           case 0x8c:
10686               GETBYTE ();
10687               switch (op[2] & 0x00)
10688               {
10689                 case 0x00:
10690                   op_semantics_80:
10691                     {
10692                       /** 1111 1100 1000 11sd rsrc rdst fmul    %1%S1, %0 */
10693 #line 939 "rx-decode.opc"
10694                       int sd AU = op[1] & 0x03;
10695 #line 939 "rx-decode.opc"
10696                       int rsrc AU = (op[2] >> 4) & 0x0f;
10697 #line 939 "rx-decode.opc"
10698                       int rdst AU = op[2] & 0x0f;
10699                       if (trace)
10700                         {
10701                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10702                                  "/** 1111 1100 1000 11sd rsrc rdst     fmul    %1%S1, %0 */",
10703                                  op[0], op[1], op[2]);
10704                           printf ("  sd = 0x%x,", sd);
10705                           printf ("  rsrc = 0x%x,", rsrc);
10706                           printf ("  rdst = 0x%x\n", rdst);
10707                         }
10708                       SYNTAX("fmul      %1%S1, %0");
10709 #line 939 "rx-decode.opc"
10710                       ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10711
10712                     }
10713                   break;
10714               }
10715             break;
10716           case 0x8d:
10717               GETBYTE ();
10718               switch (op[2] & 0x00)
10719               {
10720                 case 0x00:
10721                   goto op_semantics_80;
10722                   break;
10723               }
10724             break;
10725           case 0x8e:
10726               GETBYTE ();
10727               switch (op[2] & 0x00)
10728               {
10729                 case 0x00:
10730                   goto op_semantics_80;
10731                   break;
10732               }
10733             break;
10734           case 0x8f:
10735               GETBYTE ();
10736               switch (op[2] & 0x00)
10737               {
10738                 case 0x00:
10739                   goto op_semantics_80;
10740                   break;
10741               }
10742             break;
10743           case 0x90:
10744               GETBYTE ();
10745               switch (op[2] & 0x00)
10746               {
10747                 case 0x00:
10748                   op_semantics_81:
10749                     {
10750                       /** 1111 1100 1001 00sd rsrc rdst fdiv    %1%S1, %0 */
10751 #line 945 "rx-decode.opc"
10752                       int sd AU = op[1] & 0x03;
10753 #line 945 "rx-decode.opc"
10754                       int rsrc AU = (op[2] >> 4) & 0x0f;
10755 #line 945 "rx-decode.opc"
10756                       int rdst AU = op[2] & 0x0f;
10757                       if (trace)
10758                         {
10759                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10760                                  "/** 1111 1100 1001 00sd rsrc rdst     fdiv    %1%S1, %0 */",
10761                                  op[0], op[1], op[2]);
10762                           printf ("  sd = 0x%x,", sd);
10763                           printf ("  rsrc = 0x%x,", rsrc);
10764                           printf ("  rdst = 0x%x\n", rdst);
10765                         }
10766                       SYNTAX("fdiv      %1%S1, %0");
10767 #line 945 "rx-decode.opc"
10768                       ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10769
10770                     }
10771                   break;
10772               }
10773             break;
10774           case 0x91:
10775               GETBYTE ();
10776               switch (op[2] & 0x00)
10777               {
10778                 case 0x00:
10779                   goto op_semantics_81;
10780                   break;
10781               }
10782             break;
10783           case 0x92:
10784               GETBYTE ();
10785               switch (op[2] & 0x00)
10786               {
10787                 case 0x00:
10788                   goto op_semantics_81;
10789                   break;
10790               }
10791             break;
10792           case 0x93:
10793               GETBYTE ();
10794               switch (op[2] & 0x00)
10795               {
10796                 case 0x00:
10797                   goto op_semantics_81;
10798                   break;
10799               }
10800             break;
10801           case 0x94:
10802               GETBYTE ();
10803               switch (op[2] & 0x00)
10804               {
10805                 case 0x00:
10806                   op_semantics_82:
10807                     {
10808                       /** 1111 1100 1001 01sd rsrc rdst ftoi    %1%S1, %0 */
10809 #line 933 "rx-decode.opc"
10810                       int sd AU = op[1] & 0x03;
10811 #line 933 "rx-decode.opc"
10812                       int rsrc AU = (op[2] >> 4) & 0x0f;
10813 #line 933 "rx-decode.opc"
10814                       int rdst AU = op[2] & 0x0f;
10815                       if (trace)
10816                         {
10817                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10818                                  "/** 1111 1100 1001 01sd rsrc rdst     ftoi    %1%S1, %0 */",
10819                                  op[0], op[1], op[2]);
10820                           printf ("  sd = 0x%x,", sd);
10821                           printf ("  rsrc = 0x%x,", rsrc);
10822                           printf ("  rdst = 0x%x\n", rdst);
10823                         }
10824                       SYNTAX("ftoi      %1%S1, %0");
10825 #line 933 "rx-decode.opc"
10826                       ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10827
10828                     }
10829                   break;
10830               }
10831             break;
10832           case 0x95:
10833               GETBYTE ();
10834               switch (op[2] & 0x00)
10835               {
10836                 case 0x00:
10837                   goto op_semantics_82;
10838                   break;
10839               }
10840             break;
10841           case 0x96:
10842               GETBYTE ();
10843               switch (op[2] & 0x00)
10844               {
10845                 case 0x00:
10846                   goto op_semantics_82;
10847                   break;
10848               }
10849             break;
10850           case 0x97:
10851               GETBYTE ();
10852               switch (op[2] & 0x00)
10853               {
10854                 case 0x00:
10855                   goto op_semantics_82;
10856                   break;
10857               }
10858             break;
10859           case 0x98:
10860               GETBYTE ();
10861               switch (op[2] & 0x00)
10862               {
10863                 case 0x00:
10864                   op_semantics_83:
10865                     {
10866                       /** 1111 1100 1001 10sd rsrc rdst round   %1%S1, %0 */
10867 #line 948 "rx-decode.opc"
10868                       int sd AU = op[1] & 0x03;
10869 #line 948 "rx-decode.opc"
10870                       int rsrc AU = (op[2] >> 4) & 0x0f;
10871 #line 948 "rx-decode.opc"
10872                       int rdst AU = op[2] & 0x0f;
10873                       if (trace)
10874                         {
10875                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10876                                  "/** 1111 1100 1001 10sd rsrc rdst     round   %1%S1, %0 */",
10877                                  op[0], op[1], op[2]);
10878                           printf ("  sd = 0x%x,", sd);
10879                           printf ("  rsrc = 0x%x,", rsrc);
10880                           printf ("  rdst = 0x%x\n", rdst);
10881                         }
10882                       SYNTAX("round     %1%S1, %0");
10883 #line 948 "rx-decode.opc"
10884                       ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10885
10886                     }
10887                   break;
10888               }
10889             break;
10890           case 0x99:
10891               GETBYTE ();
10892               switch (op[2] & 0x00)
10893               {
10894                 case 0x00:
10895                   goto op_semantics_83;
10896                   break;
10897               }
10898             break;
10899           case 0x9a:
10900               GETBYTE ();
10901               switch (op[2] & 0x00)
10902               {
10903                 case 0x00:
10904                   goto op_semantics_83;
10905                   break;
10906               }
10907             break;
10908           case 0x9b:
10909               GETBYTE ();
10910               switch (op[2] & 0x00)
10911               {
10912                 case 0x00:
10913                   goto op_semantics_83;
10914                   break;
10915               }
10916             break;
10917           case 0xa0:
10918               GETBYTE ();
10919               switch (op[2] & 0x00)
10920               {
10921                 case 0x00:
10922                   op_semantics_84:
10923                     {
10924                       /** 1111 1100 1010 00sd rsrc rdst fsqrt   %1%S1, %0 */
10925 #line 1131 "rx-decode.opc"
10926                       int sd AU = op[1] & 0x03;
10927 #line 1131 "rx-decode.opc"
10928                       int rsrc AU = (op[2] >> 4) & 0x0f;
10929 #line 1131 "rx-decode.opc"
10930                       int rdst AU = op[2] & 0x0f;
10931                       if (trace)
10932                         {
10933                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10934                                  "/** 1111 1100 1010 00sd rsrc rdst     fsqrt   %1%S1, %0 */",
10935                                  op[0], op[1], op[2]);
10936                           printf ("  sd = 0x%x,", sd);
10937                           printf ("  rsrc = 0x%x,", rsrc);
10938                           printf ("  rdst = 0x%x\n", rdst);
10939                         }
10940                       SYNTAX("fsqrt     %1%S1, %0");
10941 #line 1131 "rx-decode.opc"
10942                       ID(fsqrt); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
10943
10944                     }
10945                   break;
10946               }
10947             break;
10948           case 0xa1:
10949               GETBYTE ();
10950               switch (op[2] & 0x00)
10951               {
10952                 case 0x00:
10953                   goto op_semantics_84;
10954                   break;
10955               }
10956             break;
10957           case 0xa2:
10958               GETBYTE ();
10959               switch (op[2] & 0x00)
10960               {
10961                 case 0x00:
10962                   goto op_semantics_84;
10963                   break;
10964               }
10965             break;
10966           case 0xa3:
10967               GETBYTE ();
10968               switch (op[2] & 0x00)
10969               {
10970                 case 0x00:
10971                   goto op_semantics_84;
10972                   break;
10973               }
10974             break;
10975           case 0xa4:
10976               GETBYTE ();
10977               switch (op[2] & 0x00)
10978               {
10979                 case 0x00:
10980                   op_semantics_85:
10981                     {
10982                       /** 1111 1100 1010 01sd rsrc rdst ftou    %1%S1, %0 */
10983 #line 1134 "rx-decode.opc"
10984                       int sd AU = op[1] & 0x03;
10985 #line 1134 "rx-decode.opc"
10986                       int rsrc AU = (op[2] >> 4) & 0x0f;
10987 #line 1134 "rx-decode.opc"
10988                       int rdst AU = op[2] & 0x0f;
10989                       if (trace)
10990                         {
10991                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
10992                                  "/** 1111 1100 1010 01sd rsrc rdst     ftou    %1%S1, %0 */",
10993                                  op[0], op[1], op[2]);
10994                           printf ("  sd = 0x%x,", sd);
10995                           printf ("  rsrc = 0x%x,", rsrc);
10996                           printf ("  rdst = 0x%x\n", rdst);
10997                         }
10998                       SYNTAX("ftou      %1%S1, %0");
10999 #line 1134 "rx-decode.opc"
11000                       ID(ftou); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
11001
11002                     }
11003                   break;
11004               }
11005             break;
11006           case 0xa5:
11007               GETBYTE ();
11008               switch (op[2] & 0x00)
11009               {
11010                 case 0x00:
11011                   goto op_semantics_85;
11012                   break;
11013               }
11014             break;
11015           case 0xa6:
11016               GETBYTE ();
11017               switch (op[2] & 0x00)
11018               {
11019                 case 0x00:
11020                   goto op_semantics_85;
11021                   break;
11022               }
11023             break;
11024           case 0xa7:
11025               GETBYTE ();
11026               switch (op[2] & 0x00)
11027               {
11028                 case 0x00:
11029                   goto op_semantics_85;
11030                   break;
11031               }
11032             break;
11033           case 0xc8:
11034               GETBYTE ();
11035               switch (op[2] & 0x0f)
11036               {
11037                 case 0x08:
11038                   op_semantics_86:
11039                     {
11040                       /** 1111 1100 1100 10sz rsrc 1000 dmov.d  %1, %0 */
11041 #line 1198 "rx-decode.opc"
11042                       int sz AU = op[1] & 0x03;
11043 #line 1198 "rx-decode.opc"
11044                       int rsrc AU = (op[2] >> 4) & 0x0f;
11045                       if (trace)
11046                         {
11047                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11048                                  "/** 1111 1100 1100 10sz rsrc 1000     dmov.d  %1, %0 */",
11049                                  op[0], op[1], op[2]);
11050                           printf ("  sz = 0x%x,", sz);
11051                           printf ("  rsrc = 0x%x\n", rsrc);
11052                         }
11053                       SYNTAX("dmov.d    %1, %0");
11054 #line 1198 "rx-decode.opc"
11055                       int rdst;
11056                       rx_disp(1, sz, rsrc, RX_Double, ld);
11057                       rdst = GETBYTE();
11058                       if (rdst & 0x0f)
11059                         UNSUPPORTED();
11060                       else {
11061                         ID(dmov); DDR(rdst >> 4); F_____;
11062                       }
11063
11064                     }
11065                   break;
11066                 default: UNSUPPORTED(); break;
11067               }
11068             break;
11069           case 0xc9:
11070               GETBYTE ();
11071               switch (op[2] & 0x0f)
11072               {
11073                 case 0x08:
11074                   goto op_semantics_86;
11075                   break;
11076                 default: UNSUPPORTED(); break;
11077               }
11078             break;
11079           case 0xca:
11080               GETBYTE ();
11081               switch (op[2] & 0x0f)
11082               {
11083                 case 0x08:
11084                   goto op_semantics_86;
11085                   break;
11086                 default: UNSUPPORTED(); break;
11087               }
11088             break;
11089           case 0xd0:
11090               GETBYTE ();
11091               switch (op[2] & 0x00)
11092               {
11093                 case 0x00:
11094                   op_semantics_87:
11095                     {
11096                       /** 1111 1100 1101 sz sd rdst cond        sc%1%s  %0 */
11097 #line 1065 "rx-decode.opc"
11098                       int sz AU = (op[1] >> 2) & 0x03;
11099 #line 1065 "rx-decode.opc"
11100                       int sd AU = op[1] & 0x03;
11101 #line 1065 "rx-decode.opc"
11102                       int rdst AU = (op[2] >> 4) & 0x0f;
11103 #line 1065 "rx-decode.opc"
11104                       int cond AU = op[2] & 0x0f;
11105                       if (trace)
11106                         {
11107                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11108                                  "/** 1111 1100 1101 sz sd rdst cond    sc%1%s  %0 */",
11109                                  op[0], op[1], op[2]);
11110                           printf ("  sz = 0x%x,", sz);
11111                           printf ("  sd = 0x%x,", sd);
11112                           printf ("  rdst = 0x%x,", rdst);
11113                           printf ("  cond = 0x%x\n", cond);
11114                         }
11115                       SYNTAX("sc%1%s    %0");
11116 #line 1065 "rx-decode.opc"
11117                       ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
11118
11119                     /*----------------------------------------------------------------------*/
11120                     /* RXv2 enhanced                                                    */
11121
11122                     }
11123                   break;
11124               }
11125             break;
11126           case 0xd1:
11127               GETBYTE ();
11128               switch (op[2] & 0x00)
11129               {
11130                 case 0x00:
11131                   goto op_semantics_87;
11132                   break;
11133               }
11134             break;
11135           case 0xd2:
11136               GETBYTE ();
11137               switch (op[2] & 0x00)
11138               {
11139                 case 0x00:
11140                   goto op_semantics_87;
11141                   break;
11142               }
11143             break;
11144           case 0xd3:
11145               GETBYTE ();
11146               switch (op[2] & 0x00)
11147               {
11148                 case 0x00:
11149                   goto op_semantics_87;
11150                   break;
11151               }
11152             break;
11153           case 0xd4:
11154               GETBYTE ();
11155               switch (op[2] & 0x00)
11156               {
11157                 case 0x00:
11158                   goto op_semantics_87;
11159                   break;
11160               }
11161             break;
11162           case 0xd5:
11163               GETBYTE ();
11164               switch (op[2] & 0x00)
11165               {
11166                 case 0x00:
11167                   goto op_semantics_87;
11168                   break;
11169               }
11170             break;
11171           case 0xd6:
11172               GETBYTE ();
11173               switch (op[2] & 0x00)
11174               {
11175                 case 0x00:
11176                   goto op_semantics_87;
11177                   break;
11178               }
11179             break;
11180           case 0xd7:
11181               GETBYTE ();
11182               switch (op[2] & 0x00)
11183               {
11184                 case 0x00:
11185                   goto op_semantics_87;
11186                   break;
11187               }
11188             break;
11189           case 0xd8:
11190               GETBYTE ();
11191               switch (op[2] & 0x00)
11192               {
11193                 case 0x00:
11194                   goto op_semantics_87;
11195                   break;
11196               }
11197             break;
11198           case 0xd9:
11199               GETBYTE ();
11200               switch (op[2] & 0x00)
11201               {
11202                 case 0x00:
11203                   goto op_semantics_87;
11204                   break;
11205               }
11206             break;
11207           case 0xda:
11208               GETBYTE ();
11209               switch (op[2] & 0x00)
11210               {
11211                 case 0x00:
11212                   goto op_semantics_87;
11213                   break;
11214               }
11215             break;
11216           case 0xdb:
11217               GETBYTE ();
11218               switch (op[2] & 0x00)
11219               {
11220                 case 0x00:
11221                   goto op_semantics_87;
11222                   break;
11223               }
11224             break;
11225           case 0xe0:
11226               GETBYTE ();
11227               switch (op[2] & 0x0f)
11228               {
11229                 case 0x00:
11230                 case 0x01:
11231                 case 0x02:
11232                 case 0x03:
11233                 case 0x04:
11234                 case 0x05:
11235                 case 0x06:
11236                 case 0x07:
11237                 case 0x08:
11238                 case 0x09:
11239                 case 0x0a:
11240                 case 0x0b:
11241                 case 0x0c:
11242                 case 0x0d:
11243                 case 0x0e:
11244                   op_semantics_88:
11245                     {
11246                       /** 1111 1100 111bit sd rdst cond bm%2    #%1, %0%S0 */
11247 #line 1008 "rx-decode.opc"
11248                       int bit AU = (op[1] >> 2) & 0x07;
11249 #line 1008 "rx-decode.opc"
11250                       int sd AU = op[1] & 0x03;
11251 #line 1008 "rx-decode.opc"
11252                       int rdst AU = (op[2] >> 4) & 0x0f;
11253 #line 1008 "rx-decode.opc"
11254                       int cond AU = op[2] & 0x0f;
11255                       if (trace)
11256                         {
11257                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11258                                  "/** 1111 1100 111bit sd rdst cond     bm%2    #%1, %0%S0 */",
11259                                  op[0], op[1], op[2]);
11260                           printf ("  bit = 0x%x,", bit);
11261                           printf ("  sd = 0x%x,", sd);
11262                           printf ("  rdst = 0x%x,", rdst);
11263                           printf ("  cond = 0x%x\n", cond);
11264                         }
11265                       SYNTAX("bm%2      #%1, %0%S0");
11266 #line 1008 "rx-decode.opc"
11267                       ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE);
11268
11269                     }
11270                   break;
11271                 case 0x0f:
11272                   op_semantics_89:
11273                     {
11274                       /** 1111 1100 111bit sd rdst 1111 bnot    #%1, %0%S0 */
11275 #line 996 "rx-decode.opc"
11276                       int bit AU = (op[1] >> 2) & 0x07;
11277 #line 996 "rx-decode.opc"
11278                       int sd AU = op[1] & 0x03;
11279 #line 996 "rx-decode.opc"
11280                       int rdst AU = (op[2] >> 4) & 0x0f;
11281                       if (trace)
11282                         {
11283                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
11284                                  "/** 1111 1100 111bit sd rdst 1111     bnot    #%1, %0%S0 */",
11285                                  op[0], op[1], op[2]);
11286                           printf ("  bit = 0x%x,", bit);
11287                           printf ("  sd = 0x%x,", sd);
11288                           printf ("  rdst = 0x%x\n", rdst);
11289                         }
11290                       SYNTAX("bnot      #%1, %0%S0");
11291 #line 996 "rx-decode.opc"
11292                       ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
11293
11294                     }
11295                   break;
11296               }
11297             break;
11298           case 0xe1:
11299               GETBYTE ();
11300               switch (op[2] & 0x0f)
11301               {
11302                 case 0x00:
11303                 case 0x01:
11304                 case 0x02:
11305                 case 0x03:
11306                 case 0x04:
11307                 case 0x05:
11308                 case 0x06:
11309                 case 0x07:
11310                 case 0x08:
11311                 case 0x09:
11312                 case 0x0a:
11313                 case 0x0b:
11314                 case 0x0c:
11315                 case 0x0d:
11316                 case 0x0e:
11317                   goto op_semantics_88;
11318                   break;
11319                 case 0x0f:
11320                   goto op_semantics_89;
11321                   break;
11322               }
11323             break;
11324           case 0xe2:
11325               GETBYTE ();
11326               switch (op[2] & 0x0f)
11327               {
11328                 case 0x00:
11329                 case 0x01:
11330                 case 0x02:
11331                 case 0x03:
11332                 case 0x04:
11333                 case 0x05:
11334                 case 0x06:
11335                 case 0x07:
11336                 case 0x08:
11337                 case 0x09:
11338                 case 0x0a:
11339                 case 0x0b:
11340                 case 0x0c:
11341                 case 0x0d:
11342                 case 0x0e:
11343                   goto op_semantics_88;
11344                   break;
11345                 case 0x0f:
11346                   goto op_semantics_89;
11347                   break;
11348               }
11349             break;
11350           case 0xe3:
11351               GETBYTE ();
11352               switch (op[2] & 0x0f)
11353               {
11354                 case 0x00:
11355                 case 0x01:
11356                 case 0x02:
11357                 case 0x03:
11358                 case 0x04:
11359                 case 0x05:
11360                 case 0x06:
11361                 case 0x07:
11362                 case 0x08:
11363                 case 0x09:
11364                 case 0x0a:
11365                 case 0x0b:
11366                 case 0x0c:
11367                 case 0x0d:
11368                 case 0x0e:
11369                   goto op_semantics_88;
11370                   break;
11371                 case 0x0f:
11372                   goto op_semantics_89;
11373                   break;
11374               }
11375             break;
11376           case 0xe4:
11377               GETBYTE ();
11378               switch (op[2] & 0x0f)
11379               {
11380                 case 0x00:
11381                 case 0x01:
11382                 case 0x02:
11383                 case 0x03:
11384                 case 0x04:
11385                 case 0x05:
11386                 case 0x06:
11387                 case 0x07:
11388                 case 0x08:
11389                 case 0x09:
11390                 case 0x0a:
11391                 case 0x0b:
11392                 case 0x0c:
11393                 case 0x0d:
11394                 case 0x0e:
11395                   goto op_semantics_88;
11396                   break;
11397                 case 0x0f:
11398                   goto op_semantics_89;
11399                   break;
11400               }
11401             break;
11402           case 0xe5:
11403               GETBYTE ();
11404               switch (op[2] & 0x0f)
11405               {
11406                 case 0x00:
11407                 case 0x01:
11408                 case 0x02:
11409                 case 0x03:
11410                 case 0x04:
11411                 case 0x05:
11412                 case 0x06:
11413                 case 0x07:
11414                 case 0x08:
11415                 case 0x09:
11416                 case 0x0a:
11417                 case 0x0b:
11418                 case 0x0c:
11419                 case 0x0d:
11420                 case 0x0e:
11421                   goto op_semantics_88;
11422                   break;
11423                 case 0x0f:
11424                   goto op_semantics_89;
11425                   break;
11426               }
11427             break;
11428           case 0xe6:
11429               GETBYTE ();
11430               switch (op[2] & 0x0f)
11431               {
11432                 case 0x00:
11433                 case 0x01:
11434                 case 0x02:
11435                 case 0x03:
11436                 case 0x04:
11437                 case 0x05:
11438                 case 0x06:
11439                 case 0x07:
11440                 case 0x08:
11441                 case 0x09:
11442                 case 0x0a:
11443                 case 0x0b:
11444                 case 0x0c:
11445                 case 0x0d:
11446                 case 0x0e:
11447                   goto op_semantics_88;
11448                   break;
11449                 case 0x0f:
11450                   goto op_semantics_89;
11451                   break;
11452               }
11453             break;
11454           case 0xe7:
11455               GETBYTE ();
11456               switch (op[2] & 0x0f)
11457               {
11458                 case 0x00:
11459                 case 0x01:
11460                 case 0x02:
11461                 case 0x03:
11462                 case 0x04:
11463                 case 0x05:
11464                 case 0x06:
11465                 case 0x07:
11466                 case 0x08:
11467                 case 0x09:
11468                 case 0x0a:
11469                 case 0x0b:
11470                 case 0x0c:
11471                 case 0x0d:
11472                 case 0x0e:
11473                   goto op_semantics_88;
11474                   break;
11475                 case 0x0f:
11476                   goto op_semantics_89;
11477                   break;
11478               }
11479             break;
11480           case 0xe8:
11481               GETBYTE ();
11482               switch (op[2] & 0x0f)
11483               {
11484                 case 0x00:
11485                 case 0x01:
11486                 case 0x02:
11487                 case 0x03:
11488                 case 0x04:
11489                 case 0x05:
11490                 case 0x06:
11491                 case 0x07:
11492                 case 0x08:
11493                 case 0x09:
11494                 case 0x0a:
11495                 case 0x0b:
11496                 case 0x0c:
11497                 case 0x0d:
11498                 case 0x0e:
11499                   goto op_semantics_88;
11500                   break;
11501                 case 0x0f:
11502                   goto op_semantics_89;
11503                   break;
11504               }
11505             break;
11506           case 0xe9:
11507               GETBYTE ();
11508               switch (op[2] & 0x0f)
11509               {
11510                 case 0x00:
11511                 case 0x01:
11512                 case 0x02:
11513                 case 0x03:
11514                 case 0x04:
11515                 case 0x05:
11516                 case 0x06:
11517                 case 0x07:
11518                 case 0x08:
11519                 case 0x09:
11520                 case 0x0a:
11521                 case 0x0b:
11522                 case 0x0c:
11523                 case 0x0d:
11524                 case 0x0e:
11525                   goto op_semantics_88;
11526                   break;
11527                 case 0x0f:
11528                   goto op_semantics_89;
11529                   break;
11530               }
11531             break;
11532           case 0xea:
11533               GETBYTE ();
11534               switch (op[2] & 0x0f)
11535               {
11536                 case 0x00:
11537                 case 0x01:
11538                 case 0x02:
11539                 case 0x03:
11540                 case 0x04:
11541                 case 0x05:
11542                 case 0x06:
11543                 case 0x07:
11544                 case 0x08:
11545                 case 0x09:
11546                 case 0x0a:
11547                 case 0x0b:
11548                 case 0x0c:
11549                 case 0x0d:
11550                 case 0x0e:
11551                   goto op_semantics_88;
11552                   break;
11553                 case 0x0f:
11554                   goto op_semantics_89;
11555                   break;
11556               }
11557             break;
11558           case 0xeb:
11559               GETBYTE ();
11560               switch (op[2] & 0x0f)
11561               {
11562                 case 0x00:
11563                 case 0x01:
11564                 case 0x02:
11565                 case 0x03:
11566                 case 0x04:
11567                 case 0x05:
11568                 case 0x06:
11569                 case 0x07:
11570                 case 0x08:
11571                 case 0x09:
11572                 case 0x0a:
11573                 case 0x0b:
11574                 case 0x0c:
11575                 case 0x0d:
11576                 case 0x0e:
11577                   goto op_semantics_88;
11578                   break;
11579                 case 0x0f:
11580                   goto op_semantics_89;
11581                   break;
11582               }
11583             break;
11584           case 0xec:
11585               GETBYTE ();
11586               switch (op[2] & 0x0f)
11587               {
11588                 case 0x00:
11589                 case 0x01:
11590                 case 0x02:
11591                 case 0x03:
11592                 case 0x04:
11593                 case 0x05:
11594                 case 0x06:
11595                 case 0x07:
11596                 case 0x08:
11597                 case 0x09:
11598                 case 0x0a:
11599                 case 0x0b:
11600                 case 0x0c:
11601                 case 0x0d:
11602                 case 0x0e:
11603                   goto op_semantics_88;
11604                   break;
11605                 case 0x0f:
11606                   goto op_semantics_89;
11607                   break;
11608               }
11609             break;
11610           case 0xed:
11611               GETBYTE ();
11612               switch (op[2] & 0x0f)
11613               {
11614                 case 0x00:
11615                 case 0x01:
11616                 case 0x02:
11617                 case 0x03:
11618                 case 0x04:
11619                 case 0x05:
11620                 case 0x06:
11621                 case 0x07:
11622                 case 0x08:
11623                 case 0x09:
11624                 case 0x0a:
11625                 case 0x0b:
11626                 case 0x0c:
11627                 case 0x0d:
11628                 case 0x0e:
11629                   goto op_semantics_88;
11630                   break;
11631                 case 0x0f:
11632                   goto op_semantics_89;
11633                   break;
11634               }
11635             break;
11636           case 0xee:
11637               GETBYTE ();
11638               switch (op[2] & 0x0f)
11639               {
11640                 case 0x00:
11641                 case 0x01:
11642                 case 0x02:
11643                 case 0x03:
11644                 case 0x04:
11645                 case 0x05:
11646                 case 0x06:
11647                 case 0x07:
11648                 case 0x08:
11649                 case 0x09:
11650                 case 0x0a:
11651                 case 0x0b:
11652                 case 0x0c:
11653                 case 0x0d:
11654                 case 0x0e:
11655                   goto op_semantics_88;
11656                   break;
11657                 case 0x0f:
11658                   goto op_semantics_89;
11659                   break;
11660               }
11661             break;
11662           case 0xef:
11663               GETBYTE ();
11664               switch (op[2] & 0x0f)
11665               {
11666                 case 0x00:
11667                 case 0x01:
11668                 case 0x02:
11669                 case 0x03:
11670                 case 0x04:
11671                 case 0x05:
11672                 case 0x06:
11673                 case 0x07:
11674                 case 0x08:
11675                 case 0x09:
11676                 case 0x0a:
11677                 case 0x0b:
11678                 case 0x0c:
11679                 case 0x0d:
11680                 case 0x0e:
11681                   goto op_semantics_88;
11682                   break;
11683                 case 0x0f:
11684                   goto op_semantics_89;
11685                   break;
11686               }
11687             break;
11688           case 0xf0:
11689               GETBYTE ();
11690               switch (op[2] & 0x0f)
11691               {
11692                 case 0x00:
11693                 case 0x01:
11694                 case 0x02:
11695                 case 0x03:
11696                 case 0x04:
11697                 case 0x05:
11698                 case 0x06:
11699                 case 0x07:
11700                 case 0x08:
11701                 case 0x09:
11702                 case 0x0a:
11703                 case 0x0b:
11704                 case 0x0c:
11705                 case 0x0d:
11706                 case 0x0e:
11707                   goto op_semantics_88;
11708                   break;
11709                 case 0x0f:
11710                   goto op_semantics_89;
11711                   break;
11712               }
11713             break;
11714           case 0xf1:
11715               GETBYTE ();
11716               switch (op[2] & 0x0f)
11717               {
11718                 case 0x00:
11719                 case 0x01:
11720                 case 0x02:
11721                 case 0x03:
11722                 case 0x04:
11723                 case 0x05:
11724                 case 0x06:
11725                 case 0x07:
11726                 case 0x08:
11727                 case 0x09:
11728                 case 0x0a:
11729                 case 0x0b:
11730                 case 0x0c:
11731                 case 0x0d:
11732                 case 0x0e:
11733                   goto op_semantics_88;
11734                   break;
11735                 case 0x0f:
11736                   goto op_semantics_89;
11737                   break;
11738               }
11739             break;
11740           case 0xf2:
11741               GETBYTE ();
11742               switch (op[2] & 0x0f)
11743               {
11744                 case 0x00:
11745                 case 0x01:
11746                 case 0x02:
11747                 case 0x03:
11748                 case 0x04:
11749                 case 0x05:
11750                 case 0x06:
11751                 case 0x07:
11752                 case 0x08:
11753                 case 0x09:
11754                 case 0x0a:
11755                 case 0x0b:
11756                 case 0x0c:
11757                 case 0x0d:
11758                 case 0x0e:
11759                   goto op_semantics_88;
11760                   break;
11761                 case 0x0f:
11762                   goto op_semantics_89;
11763                   break;
11764               }
11765             break;
11766           case 0xf3:
11767               GETBYTE ();
11768               switch (op[2] & 0x0f)
11769               {
11770                 case 0x00:
11771                 case 0x01:
11772                 case 0x02:
11773                 case 0x03:
11774                 case 0x04:
11775                 case 0x05:
11776                 case 0x06:
11777                 case 0x07:
11778                 case 0x08:
11779                 case 0x09:
11780                 case 0x0a:
11781                 case 0x0b:
11782                 case 0x0c:
11783                 case 0x0d:
11784                 case 0x0e:
11785                   goto op_semantics_88;
11786                   break;
11787                 case 0x0f:
11788                   goto op_semantics_89;
11789                   break;
11790               }
11791             break;
11792           case 0xf4:
11793               GETBYTE ();
11794               switch (op[2] & 0x0f)
11795               {
11796                 case 0x00:
11797                 case 0x01:
11798                 case 0x02:
11799                 case 0x03:
11800                 case 0x04:
11801                 case 0x05:
11802                 case 0x06:
11803                 case 0x07:
11804                 case 0x08:
11805                 case 0x09:
11806                 case 0x0a:
11807                 case 0x0b:
11808                 case 0x0c:
11809                 case 0x0d:
11810                 case 0x0e:
11811                   goto op_semantics_88;
11812                   break;
11813                 case 0x0f:
11814                   goto op_semantics_89;
11815                   break;
11816               }
11817             break;
11818           case 0xf5:
11819               GETBYTE ();
11820               switch (op[2] & 0x0f)
11821               {
11822                 case 0x00:
11823                 case 0x01:
11824                 case 0x02:
11825                 case 0x03:
11826                 case 0x04:
11827                 case 0x05:
11828                 case 0x06:
11829                 case 0x07:
11830                 case 0x08:
11831                 case 0x09:
11832                 case 0x0a:
11833                 case 0x0b:
11834                 case 0x0c:
11835                 case 0x0d:
11836                 case 0x0e:
11837                   goto op_semantics_88;
11838                   break;
11839                 case 0x0f:
11840                   goto op_semantics_89;
11841                   break;
11842               }
11843             break;
11844           case 0xf6:
11845               GETBYTE ();
11846               switch (op[2] & 0x0f)
11847               {
11848                 case 0x00:
11849                 case 0x01:
11850                 case 0x02:
11851                 case 0x03:
11852                 case 0x04:
11853                 case 0x05:
11854                 case 0x06:
11855                 case 0x07:
11856                 case 0x08:
11857                 case 0x09:
11858                 case 0x0a:
11859                 case 0x0b:
11860                 case 0x0c:
11861                 case 0x0d:
11862                 case 0x0e:
11863                   goto op_semantics_88;
11864                   break;
11865                 case 0x0f:
11866                   goto op_semantics_89;
11867                   break;
11868               }
11869             break;
11870           case 0xf7:
11871               GETBYTE ();
11872               switch (op[2] & 0x0f)
11873               {
11874                 case 0x00:
11875                 case 0x01:
11876                 case 0x02:
11877                 case 0x03:
11878                 case 0x04:
11879                 case 0x05:
11880                 case 0x06:
11881                 case 0x07:
11882                 case 0x08:
11883                 case 0x09:
11884                 case 0x0a:
11885                 case 0x0b:
11886                 case 0x0c:
11887                 case 0x0d:
11888                 case 0x0e:
11889                   goto op_semantics_88;
11890                   break;
11891                 case 0x0f:
11892                   goto op_semantics_89;
11893                   break;
11894               }
11895             break;
11896           case 0xf8:
11897               GETBYTE ();
11898               switch (op[2] & 0x0f)
11899               {
11900                 case 0x00:
11901                 case 0x01:
11902                 case 0x02:
11903                 case 0x03:
11904                 case 0x04:
11905                 case 0x05:
11906                 case 0x06:
11907                 case 0x07:
11908                 case 0x08:
11909                 case 0x09:
11910                 case 0x0a:
11911                 case 0x0b:
11912                 case 0x0c:
11913                 case 0x0d:
11914                 case 0x0e:
11915                   goto op_semantics_88;
11916                   break;
11917                 case 0x0f:
11918                   goto op_semantics_89;
11919                   break;
11920               }
11921             break;
11922           case 0xf9:
11923               GETBYTE ();
11924               switch (op[2] & 0x0f)
11925               {
11926                 case 0x00:
11927                 case 0x01:
11928                 case 0x02:
11929                 case 0x03:
11930                 case 0x04:
11931                 case 0x05:
11932                 case 0x06:
11933                 case 0x07:
11934                 case 0x08:
11935                 case 0x09:
11936                 case 0x0a:
11937                 case 0x0b:
11938                 case 0x0c:
11939                 case 0x0d:
11940                 case 0x0e:
11941                   goto op_semantics_88;
11942                   break;
11943                 case 0x0f:
11944                   goto op_semantics_89;
11945                   break;
11946               }
11947             break;
11948           case 0xfa:
11949               GETBYTE ();
11950               switch (op[2] & 0x0f)
11951               {
11952                 case 0x00:
11953                 case 0x01:
11954                 case 0x02:
11955                 case 0x03:
11956                 case 0x04:
11957                 case 0x05:
11958                 case 0x06:
11959                 case 0x07:
11960                 case 0x08:
11961                 case 0x09:
11962                 case 0x0a:
11963                 case 0x0b:
11964                 case 0x0c:
11965                 case 0x0d:
11966                 case 0x0e:
11967                   goto op_semantics_88;
11968                   break;
11969                 case 0x0f:
11970                   goto op_semantics_89;
11971                   break;
11972               }
11973             break;
11974           case 0xfb:
11975               GETBYTE ();
11976               switch (op[2] & 0x0f)
11977               {
11978                 case 0x00:
11979                 case 0x01:
11980                 case 0x02:
11981                 case 0x03:
11982                 case 0x04:
11983                 case 0x05:
11984                 case 0x06:
11985                 case 0x07:
11986                 case 0x08:
11987                 case 0x09:
11988                 case 0x0a:
11989                 case 0x0b:
11990                 case 0x0c:
11991                 case 0x0d:
11992                 case 0x0e:
11993                   goto op_semantics_88;
11994                   break;
11995                 case 0x0f:
11996                   goto op_semantics_89;
11997                   break;
11998               }
11999             break;
12000           case 0xfc:
12001               GETBYTE ();
12002               switch (op[2] & 0x0f)
12003               {
12004                 case 0x00:
12005                 case 0x01:
12006                 case 0x02:
12007                 case 0x03:
12008                 case 0x04:
12009                 case 0x05:
12010                 case 0x06:
12011                 case 0x07:
12012                 case 0x08:
12013                 case 0x09:
12014                 case 0x0a:
12015                 case 0x0b:
12016                 case 0x0c:
12017                 case 0x0d:
12018                 case 0x0e:
12019                   goto op_semantics_88;
12020                   break;
12021                 case 0x0f:
12022                   goto op_semantics_89;
12023                   break;
12024               }
12025             break;
12026           case 0xfd:
12027               GETBYTE ();
12028               switch (op[2] & 0x0f)
12029               {
12030                 case 0x00:
12031                 case 0x01:
12032                 case 0x02:
12033                 case 0x03:
12034                 case 0x04:
12035                 case 0x05:
12036                 case 0x06:
12037                 case 0x07:
12038                 case 0x08:
12039                 case 0x09:
12040                 case 0x0a:
12041                 case 0x0b:
12042                 case 0x0c:
12043                 case 0x0d:
12044                 case 0x0e:
12045                   goto op_semantics_88;
12046                   break;
12047                 case 0x0f:
12048                   goto op_semantics_89;
12049                   break;
12050               }
12051             break;
12052           case 0xfe:
12053               GETBYTE ();
12054               switch (op[2] & 0x0f)
12055               {
12056                 case 0x00:
12057                 case 0x01:
12058                 case 0x02:
12059                 case 0x03:
12060                 case 0x04:
12061                 case 0x05:
12062                 case 0x06:
12063                 case 0x07:
12064                 case 0x08:
12065                 case 0x09:
12066                 case 0x0a:
12067                 case 0x0b:
12068                 case 0x0c:
12069                 case 0x0d:
12070                 case 0x0e:
12071                   goto op_semantics_88;
12072                   break;
12073                 case 0x0f:
12074                   goto op_semantics_89;
12075                   break;
12076               }
12077             break;
12078           case 0xff:
12079               GETBYTE ();
12080               switch (op[2] & 0x0f)
12081               {
12082                 case 0x00:
12083                 case 0x01:
12084                 case 0x02:
12085                 case 0x03:
12086                 case 0x04:
12087                 case 0x05:
12088                 case 0x06:
12089                 case 0x07:
12090                 case 0x08:
12091                 case 0x09:
12092                 case 0x0a:
12093                 case 0x0b:
12094                 case 0x0c:
12095                 case 0x0d:
12096                 case 0x0e:
12097                   goto op_semantics_88;
12098                   break;
12099                 case 0x0f:
12100                   goto op_semantics_89;
12101                   break;
12102               }
12103             break;
12104           default: UNSUPPORTED(); break;
12105         }
12106       break;
12107     case 0xfd:
12108         GETBYTE ();
12109         switch (op[1] & 0xff)
12110         {
12111           case 0x00:
12112               GETBYTE ();
12113               switch (op[2] & 0x00)
12114               {
12115                 case 0x00:
12116                   op_semantics_90:
12117                     {
12118                       /** 1111 1101 0000 a000 srca srcb mulhi   %1, %2, %0 */
12119 #line 873 "rx-decode.opc"
12120                       int a AU = (op[1] >> 3) & 0x01;
12121 #line 873 "rx-decode.opc"
12122                       int srca AU = (op[2] >> 4) & 0x0f;
12123 #line 873 "rx-decode.opc"
12124                       int srcb AU = op[2] & 0x0f;
12125                       if (trace)
12126                         {
12127                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12128                                  "/** 1111 1101 0000 a000 srca srcb     mulhi   %1, %2, %0 */",
12129                                  op[0], op[1], op[2]);
12130                           printf ("  a = 0x%x,", a);
12131                           printf ("  srca = 0x%x,", srca);
12132                           printf ("  srcb = 0x%x\n", srcb);
12133                         }
12134                       SYNTAX("mulhi     %1, %2, %0");
12135 #line 873 "rx-decode.opc"
12136                       ID(mulhi); DR(a+32); SR(srca); S2R(srcb); F_____;
12137
12138                     }
12139                   break;
12140               }
12141             break;
12142           case 0x01:
12143               GETBYTE ();
12144               switch (op[2] & 0x00)
12145               {
12146                 case 0x00:
12147                   op_semantics_91:
12148                     {
12149                       /** 1111 1101 0000 a001 srca srcb mullo   %1, %2, %0 */
12150 #line 876 "rx-decode.opc"
12151                       int a AU = (op[1] >> 3) & 0x01;
12152 #line 876 "rx-decode.opc"
12153                       int srca AU = (op[2] >> 4) & 0x0f;
12154 #line 876 "rx-decode.opc"
12155                       int srcb AU = op[2] & 0x0f;
12156                       if (trace)
12157                         {
12158                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12159                                  "/** 1111 1101 0000 a001 srca srcb     mullo   %1, %2, %0 */",
12160                                  op[0], op[1], op[2]);
12161                           printf ("  a = 0x%x,", a);
12162                           printf ("  srca = 0x%x,", srca);
12163                           printf ("  srcb = 0x%x\n", srcb);
12164                         }
12165                       SYNTAX("mullo     %1, %2, %0");
12166 #line 876 "rx-decode.opc"
12167                       ID(mullo); DR(a+32); SR(srca); S2R(srcb); F_____;
12168
12169                     }
12170                   break;
12171               }
12172             break;
12173           case 0x02:
12174               GETBYTE ();
12175               switch (op[2] & 0x00)
12176               {
12177                 case 0x00:
12178                   op_semantics_92:
12179                     {
12180                       /** 1111 1101 0000 a010 srca srcb mullh   %1, %2, %0 */
12181 #line 1104 "rx-decode.opc"
12182                       int a AU = (op[1] >> 3) & 0x01;
12183 #line 1104 "rx-decode.opc"
12184                       int srca AU = (op[2] >> 4) & 0x0f;
12185 #line 1104 "rx-decode.opc"
12186                       int srcb AU = op[2] & 0x0f;
12187                       if (trace)
12188                         {
12189                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12190                                  "/** 1111 1101 0000 a010 srca srcb     mullh   %1, %2, %0 */",
12191                                  op[0], op[1], op[2]);
12192                           printf ("  a = 0x%x,", a);
12193                           printf ("  srca = 0x%x,", srca);
12194                           printf ("  srcb = 0x%x\n", srcb);
12195                         }
12196                       SYNTAX("mullh     %1, %2, %0");
12197 #line 1104 "rx-decode.opc"
12198                       ID(mullh); DR(a+32); SR(srca); S2R(srcb); F_____;
12199
12200                     }
12201                   break;
12202               }
12203             break;
12204           case 0x03:
12205               GETBYTE ();
12206               switch (op[2] & 0x00)
12207               {
12208                 case 0x00:
12209                   op_semantics_93:
12210                     {
12211                       /** 1111 1101 0000 a011 srca srcb         emula   %1, %2, %0 */
12212 #line 1089 "rx-decode.opc"
12213                       int a AU = (op[1] >> 3) & 0x01;
12214 #line 1089 "rx-decode.opc"
12215                       int srca AU = (op[2] >> 4) & 0x0f;
12216 #line 1089 "rx-decode.opc"
12217                       int srcb AU = op[2] & 0x0f;
12218                       if (trace)
12219                         {
12220                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12221                                  "/** 1111 1101 0000 a011 srca srcb     emula   %1, %2, %0 */",
12222                                  op[0], op[1], op[2]);
12223                           printf ("  a = 0x%x,", a);
12224                           printf ("  srca = 0x%x,", srca);
12225                           printf ("  srcb = 0x%x\n", srcb);
12226                         }
12227                       SYNTAX("emula     %1, %2, %0");
12228 #line 1089 "rx-decode.opc"
12229                       ID(emula); DR(a+32); SR(srca); S2R(srcb); F_____;
12230
12231                     }
12232                   break;
12233               }
12234             break;
12235           case 0x04:
12236               GETBYTE ();
12237               switch (op[2] & 0x00)
12238               {
12239                 case 0x00:
12240                   op_semantics_94:
12241                     {
12242                       /** 1111 1101 0000 a100 srca srcb machi   %1, %2, %0 */
12243 #line 879 "rx-decode.opc"
12244                       int a AU = (op[1] >> 3) & 0x01;
12245 #line 879 "rx-decode.opc"
12246                       int srca AU = (op[2] >> 4) & 0x0f;
12247 #line 879 "rx-decode.opc"
12248                       int srcb AU = op[2] & 0x0f;
12249                       if (trace)
12250                         {
12251                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12252                                  "/** 1111 1101 0000 a100 srca srcb     machi   %1, %2, %0 */",
12253                                  op[0], op[1], op[2]);
12254                           printf ("  a = 0x%x,", a);
12255                           printf ("  srca = 0x%x,", srca);
12256                           printf ("  srcb = 0x%x\n", srcb);
12257                         }
12258                       SYNTAX("machi     %1, %2, %0");
12259 #line 879 "rx-decode.opc"
12260                       ID(machi); DR(a+32); SR(srca); S2R(srcb); F_____;
12261
12262                     }
12263                   break;
12264               }
12265             break;
12266           case 0x05:
12267               GETBYTE ();
12268               switch (op[2] & 0x00)
12269               {
12270                 case 0x00:
12271                   op_semantics_95:
12272                     {
12273                       /** 1111 1101 0000 a101 srca srcb maclo   %1, %2, %0 */
12274 #line 882 "rx-decode.opc"
12275                       int a AU = (op[1] >> 3) & 0x01;
12276 #line 882 "rx-decode.opc"
12277                       int srca AU = (op[2] >> 4) & 0x0f;
12278 #line 882 "rx-decode.opc"
12279                       int srcb AU = op[2] & 0x0f;
12280                       if (trace)
12281                         {
12282                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12283                                  "/** 1111 1101 0000 a101 srca srcb     maclo   %1, %2, %0 */",
12284                                  op[0], op[1], op[2]);
12285                           printf ("  a = 0x%x,", a);
12286                           printf ("  srca = 0x%x,", srca);
12287                           printf ("  srcb = 0x%x\n", srcb);
12288                         }
12289                       SYNTAX("maclo     %1, %2, %0");
12290 #line 882 "rx-decode.opc"
12291                       ID(maclo); DR(a+32); SR(srca); S2R(srcb); F_____;
12292
12293                     }
12294                   break;
12295               }
12296             break;
12297           case 0x06:
12298               GETBYTE ();
12299               switch (op[2] & 0x00)
12300               {
12301                 case 0x00:
12302                   op_semantics_96:
12303                     {
12304                       /** 1111 1101 0000 a110 srca srcb maclh   %1, %2, %0 */
12305 #line 1092 "rx-decode.opc"
12306                       int a AU = (op[1] >> 3) & 0x01;
12307 #line 1092 "rx-decode.opc"
12308                       int srca AU = (op[2] >> 4) & 0x0f;
12309 #line 1092 "rx-decode.opc"
12310                       int srcb AU = op[2] & 0x0f;
12311                       if (trace)
12312                         {
12313                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12314                                  "/** 1111 1101 0000 a110 srca srcb     maclh   %1, %2, %0 */",
12315                                  op[0], op[1], op[2]);
12316                           printf ("  a = 0x%x,", a);
12317                           printf ("  srca = 0x%x,", srca);
12318                           printf ("  srcb = 0x%x\n", srcb);
12319                         }
12320                       SYNTAX("maclh     %1, %2, %0");
12321 #line 1092 "rx-decode.opc"
12322                       ID(maclh); DR(a+32); SR(srca); S2R(srcb); F_____;
12323
12324                     }
12325                   break;
12326               }
12327             break;
12328           case 0x07:
12329               GETBYTE ();
12330               switch (op[2] & 0x00)
12331               {
12332                 case 0x00:
12333                   op_semantics_97:
12334                     {
12335                       /** 1111 1101 0000 a111 srca srcb         emaca   %1, %2, %0 */
12336 #line 1083 "rx-decode.opc"
12337                       int a AU = (op[1] >> 3) & 0x01;
12338 #line 1083 "rx-decode.opc"
12339                       int srca AU = (op[2] >> 4) & 0x0f;
12340 #line 1083 "rx-decode.opc"
12341                       int srcb AU = op[2] & 0x0f;
12342                       if (trace)
12343                         {
12344                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12345                                  "/** 1111 1101 0000 a111 srca srcb     emaca   %1, %2, %0 */",
12346                                  op[0], op[1], op[2]);
12347                           printf ("  a = 0x%x,", a);
12348                           printf ("  srca = 0x%x,", srca);
12349                           printf ("  srcb = 0x%x\n", srcb);
12350                         }
12351                       SYNTAX("emaca     %1, %2, %0");
12352 #line 1083 "rx-decode.opc"
12353                       ID(emaca); DR(a+32); SR(srca); S2R(srcb); F_____;
12354
12355                     }
12356                   break;
12357               }
12358             break;
12359           case 0x08:
12360               GETBYTE ();
12361               switch (op[2] & 0x00)
12362               {
12363                 case 0x00:
12364                   goto op_semantics_90;
12365                   break;
12366               }
12367             break;
12368           case 0x09:
12369               GETBYTE ();
12370               switch (op[2] & 0x00)
12371               {
12372                 case 0x00:
12373                   goto op_semantics_91;
12374                   break;
12375               }
12376             break;
12377           case 0x0a:
12378               GETBYTE ();
12379               switch (op[2] & 0x00)
12380               {
12381                 case 0x00:
12382                   goto op_semantics_92;
12383                   break;
12384               }
12385             break;
12386           case 0x0b:
12387               GETBYTE ();
12388               switch (op[2] & 0x00)
12389               {
12390                 case 0x00:
12391                   goto op_semantics_93;
12392                   break;
12393               }
12394             break;
12395           case 0x0c:
12396               GETBYTE ();
12397               switch (op[2] & 0x00)
12398               {
12399                 case 0x00:
12400                   goto op_semantics_94;
12401                   break;
12402               }
12403             break;
12404           case 0x0d:
12405               GETBYTE ();
12406               switch (op[2] & 0x00)
12407               {
12408                 case 0x00:
12409                   goto op_semantics_95;
12410                   break;
12411               }
12412             break;
12413           case 0x0e:
12414               GETBYTE ();
12415               switch (op[2] & 0x00)
12416               {
12417                 case 0x00:
12418                   goto op_semantics_96;
12419                   break;
12420               }
12421             break;
12422           case 0x0f:
12423               GETBYTE ();
12424               switch (op[2] & 0x00)
12425               {
12426                 case 0x00:
12427                   goto op_semantics_97;
12428                   break;
12429               }
12430             break;
12431           case 0x17:
12432               GETBYTE ();
12433               switch (op[2] & 0x70)
12434               {
12435                 case 0x00:
12436                     {
12437                       /** 1111 1101 0001 0111 a000 rsrc mvtachi %1, %0 */
12438 #line 885 "rx-decode.opc"
12439                       int a AU = (op[2] >> 7) & 0x01;
12440 #line 885 "rx-decode.opc"
12441                       int rsrc AU = op[2] & 0x0f;
12442                       if (trace)
12443                         {
12444                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12445                                  "/** 1111 1101 0001 0111 a000 rsrc     mvtachi %1, %0 */",
12446                                  op[0], op[1], op[2]);
12447                           printf ("  a = 0x%x,", a);
12448                           printf ("  rsrc = 0x%x\n", rsrc);
12449                         }
12450                       SYNTAX("mvtachi   %1, %0");
12451 #line 885 "rx-decode.opc"
12452                       ID(mvtachi); DR(a+32); SR(rsrc); F_____;
12453
12454                     }
12455                   break;
12456                 case 0x10:
12457                     {
12458                       /** 1111 1101 0001 0111 a001 rsrc mvtaclo %1, %0 */
12459 #line 888 "rx-decode.opc"
12460                       int a AU = (op[2] >> 7) & 0x01;
12461 #line 888 "rx-decode.opc"
12462                       int rsrc AU = op[2] & 0x0f;
12463                       if (trace)
12464                         {
12465                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12466                                  "/** 1111 1101 0001 0111 a001 rsrc     mvtaclo %1, %0 */",
12467                                  op[0], op[1], op[2]);
12468                           printf ("  a = 0x%x,", a);
12469                           printf ("  rsrc = 0x%x\n", rsrc);
12470                         }
12471                       SYNTAX("mvtaclo   %1, %0");
12472 #line 888 "rx-decode.opc"
12473                       ID(mvtaclo); DR(a+32); SR(rsrc); F_____;
12474
12475                     }
12476                   break;
12477                 case 0x30:
12478                     {
12479                       /** 1111 1101 0001 0111 a011 rdst mvtacgu %0, %1 */
12480 #line 1110 "rx-decode.opc"
12481                       int a AU = (op[2] >> 7) & 0x01;
12482 #line 1110 "rx-decode.opc"
12483                       int rdst AU = op[2] & 0x0f;
12484                       if (trace)
12485                         {
12486                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12487                                  "/** 1111 1101 0001 0111 a011 rdst     mvtacgu %0, %1 */",
12488                                  op[0], op[1], op[2]);
12489                           printf ("  a = 0x%x,", a);
12490                           printf ("  rdst = 0x%x\n", rdst);
12491                         }
12492                       SYNTAX("mvtacgu   %0, %1");
12493 #line 1110 "rx-decode.opc"
12494                       ID(mvtacgu); DR(a+32); SR(rdst); F_____;
12495
12496                     }
12497                   break;
12498                 default: UNSUPPORTED(); break;
12499               }
12500             break;
12501           case 0x18:
12502               GETBYTE ();
12503               switch (op[2] & 0x6f)
12504               {
12505                 case 0x00:
12506                     {
12507                       /** 1111 1101 0001 1000 a00i 0000 racw    #%1, %0 */
12508 #line 900 "rx-decode.opc"
12509                       int a AU = (op[2] >> 7) & 0x01;
12510 #line 900 "rx-decode.opc"
12511                       int i AU = (op[2] >> 4) & 0x01;
12512                       if (trace)
12513                         {
12514                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12515                                  "/** 1111 1101 0001 1000 a00i 0000     racw    #%1, %0 */",
12516                                  op[0], op[1], op[2]);
12517                           printf ("  a = 0x%x,", a);
12518                           printf ("  i = 0x%x\n", i);
12519                         }
12520                       SYNTAX("racw      #%1, %0");
12521 #line 900 "rx-decode.opc"
12522                       ID(racw); SC(i+1); DR(a+32); F_____;
12523
12524                     /*----------------------------------------------------------------------*/
12525                     /* SAT                                                                      */
12526
12527                     }
12528                   break;
12529                 case 0x40:
12530                     {
12531                       /** 1111 1101 0001 1000 a10i 0000 rdacw   #%1, %0 */
12532 #line 1119 "rx-decode.opc"
12533                       int a AU = (op[2] >> 7) & 0x01;
12534 #line 1119 "rx-decode.opc"
12535                       int i AU = (op[2] >> 4) & 0x01;
12536                       if (trace)
12537                         {
12538                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12539                                  "/** 1111 1101 0001 1000 a10i 0000     rdacw   #%1, %0 */",
12540                                  op[0], op[1], op[2]);
12541                           printf ("  a = 0x%x,", a);
12542                           printf ("  i = 0x%x\n", i);
12543                         }
12544                       SYNTAX("rdacw     #%1, %0");
12545 #line 1119 "rx-decode.opc"
12546                       ID(rdacw); SC(i+1); DR(a+32); F_____;
12547
12548                     }
12549                   break;
12550                 default: UNSUPPORTED(); break;
12551               }
12552             break;
12553           case 0x19:
12554               GETBYTE ();
12555               switch (op[2] & 0x6f)
12556               {
12557                 case 0x00:
12558                     {
12559                       /** 1111 1101 0001 1001 a00i 0000 racl    #%1, %0 */
12560 #line 1113 "rx-decode.opc"
12561                       int a AU = (op[2] >> 7) & 0x01;
12562 #line 1113 "rx-decode.opc"
12563                       int i AU = (op[2] >> 4) & 0x01;
12564                       if (trace)
12565                         {
12566                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12567                                  "/** 1111 1101 0001 1001 a00i 0000     racl    #%1, %0 */",
12568                                  op[0], op[1], op[2]);
12569                           printf ("  a = 0x%x,", a);
12570                           printf ("  i = 0x%x\n", i);
12571                         }
12572                       SYNTAX("racl      #%1, %0");
12573 #line 1113 "rx-decode.opc"
12574                       ID(racl); SC(i+1); DR(a+32); F_____;
12575
12576                     }
12577                   break;
12578                 case 0x40:
12579                     {
12580                       /** 1111 1101 0001 1001 a10i 0000 rdacl   #%1, %0 */
12581 #line 1116 "rx-decode.opc"
12582                       int a AU = (op[2] >> 7) & 0x01;
12583 #line 1116 "rx-decode.opc"
12584                       int i AU = (op[2] >> 4) & 0x01;
12585                       if (trace)
12586                         {
12587                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12588                                  "/** 1111 1101 0001 1001 a10i 0000     rdacl   #%1, %0 */",
12589                                  op[0], op[1], op[2]);
12590                           printf ("  a = 0x%x,", a);
12591                           printf ("  i = 0x%x\n", i);
12592                         }
12593                       SYNTAX("rdacl     #%1, %0");
12594 #line 1116 "rx-decode.opc"
12595                       ID(rdacl); SC(i+1); DR(a+32); F_____;
12596
12597                     }
12598                   break;
12599                 default: UNSUPPORTED(); break;
12600               }
12601             break;
12602           case 0x1e:
12603               GETBYTE ();
12604               switch (op[2] & 0x30)
12605               {
12606                 case 0x00:
12607                   op_semantics_98:
12608                     {
12609                       /** 1111 1101 0001 111i a m00 rdst        mvfachi #%2, %1, %0 */
12610 #line 891 "rx-decode.opc"
12611                       int i AU = op[1] & 0x01;
12612 #line 891 "rx-decode.opc"
12613                       int a AU = (op[2] >> 7) & 0x01;
12614 #line 891 "rx-decode.opc"
12615                       int m AU = (op[2] >> 6) & 0x01;
12616 #line 891 "rx-decode.opc"
12617                       int rdst AU = op[2] & 0x0f;
12618                       if (trace)
12619                         {
12620                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12621                                  "/** 1111 1101 0001 111i a m00 rdst    mvfachi #%2, %1, %0 */",
12622                                  op[0], op[1], op[2]);
12623                           printf ("  i = 0x%x,", i);
12624                           printf ("  a = 0x%x,", a);
12625                           printf ("  m = 0x%x,", m);
12626                           printf ("  rdst = 0x%x\n", rdst);
12627                         }
12628                       SYNTAX("mvfachi   #%2, %1, %0");
12629 #line 891 "rx-decode.opc"
12630                       ID(mvfachi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12631
12632                     }
12633                   break;
12634                 case 0x10:
12635                   op_semantics_99:
12636                     {
12637                       /** 1111 1101 0001 111i a m01 rdst        mvfaclo #%2, %1, %0 */
12638 #line 897 "rx-decode.opc"
12639                       int i AU = op[1] & 0x01;
12640 #line 897 "rx-decode.opc"
12641                       int a AU = (op[2] >> 7) & 0x01;
12642 #line 897 "rx-decode.opc"
12643                       int m AU = (op[2] >> 6) & 0x01;
12644 #line 897 "rx-decode.opc"
12645                       int rdst AU = op[2] & 0x0f;
12646                       if (trace)
12647                         {
12648                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12649                                  "/** 1111 1101 0001 111i a m01 rdst    mvfaclo #%2, %1, %0 */",
12650                                  op[0], op[1], op[2]);
12651                           printf ("  i = 0x%x,", i);
12652                           printf ("  a = 0x%x,", a);
12653                           printf ("  m = 0x%x,", m);
12654                           printf ("  rdst = 0x%x\n", rdst);
12655                         }
12656                       SYNTAX("mvfaclo   #%2, %1, %0");
12657 #line 897 "rx-decode.opc"
12658                       ID(mvfaclo); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12659
12660                     }
12661                   break;
12662                 case 0x20:
12663                   op_semantics_100:
12664                     {
12665                       /** 1111 1101 0001 111i a m10 rdst        mvfacmi #%2, %1, %0 */
12666 #line 894 "rx-decode.opc"
12667                       int i AU = op[1] & 0x01;
12668 #line 894 "rx-decode.opc"
12669                       int a AU = (op[2] >> 7) & 0x01;
12670 #line 894 "rx-decode.opc"
12671                       int m AU = (op[2] >> 6) & 0x01;
12672 #line 894 "rx-decode.opc"
12673                       int rdst AU = op[2] & 0x0f;
12674                       if (trace)
12675                         {
12676                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12677                                  "/** 1111 1101 0001 111i a m10 rdst    mvfacmi #%2, %1, %0 */",
12678                                  op[0], op[1], op[2]);
12679                           printf ("  i = 0x%x,", i);
12680                           printf ("  a = 0x%x,", a);
12681                           printf ("  m = 0x%x,", m);
12682                           printf ("  rdst = 0x%x\n", rdst);
12683                         }
12684                       SYNTAX("mvfacmi   #%2, %1, %0");
12685 #line 894 "rx-decode.opc"
12686                       ID(mvfacmi); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12687
12688                     }
12689                   break;
12690                 case 0x30:
12691                   op_semantics_101:
12692                     {
12693                       /** 1111 1101 0001 111i a m11 rdst        mvfacgu #%2, %1, %0 */
12694 #line 1107 "rx-decode.opc"
12695                       int i AU = op[1] & 0x01;
12696 #line 1107 "rx-decode.opc"
12697                       int a AU = (op[2] >> 7) & 0x01;
12698 #line 1107 "rx-decode.opc"
12699                       int m AU = (op[2] >> 6) & 0x01;
12700 #line 1107 "rx-decode.opc"
12701                       int rdst AU = op[2] & 0x0f;
12702                       if (trace)
12703                         {
12704                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12705                                  "/** 1111 1101 0001 111i a m11 rdst    mvfacgu #%2, %1, %0 */",
12706                                  op[0], op[1], op[2]);
12707                           printf ("  i = 0x%x,", i);
12708                           printf ("  a = 0x%x,", a);
12709                           printf ("  m = 0x%x,", m);
12710                           printf ("  rdst = 0x%x\n", rdst);
12711                         }
12712                       SYNTAX("mvfacgu   #%2, %1, %0");
12713 #line 1107 "rx-decode.opc"
12714                       ID(mvfacgu); S2C(((i^1)<<1)|m); SR(a+32); DR(rdst); F_____;
12715
12716                     }
12717                   break;
12718               }
12719             break;
12720           case 0x1f:
12721               GETBYTE ();
12722               switch (op[2] & 0x30)
12723               {
12724                 case 0x00:
12725                   goto op_semantics_98;
12726                   break;
12727                 case 0x10:
12728                   goto op_semantics_99;
12729                   break;
12730                 case 0x20:
12731                   goto op_semantics_100;
12732                   break;
12733                 case 0x30:
12734                   goto op_semantics_101;
12735                   break;
12736               }
12737             break;
12738           case 0x20:
12739               GETBYTE ();
12740               switch (op[2] & 0x00)
12741               {
12742                 case 0x00:
12743                   op_semantics_102:
12744                     {
12745                       /** 1111 1101 0010 0p sz rdst rsrc        mov%s   %1, %0 */
12746 #line 369 "rx-decode.opc"
12747                       int p AU = (op[1] >> 2) & 0x01;
12748 #line 369 "rx-decode.opc"
12749                       int sz AU = op[1] & 0x03;
12750 #line 369 "rx-decode.opc"
12751                       int rdst AU = (op[2] >> 4) & 0x0f;
12752 #line 369 "rx-decode.opc"
12753                       int rsrc AU = op[2] & 0x0f;
12754                       if (trace)
12755                         {
12756                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12757                                  "/** 1111 1101 0010 0p sz rdst rsrc    mov%s   %1, %0 */",
12758                                  op[0], op[1], op[2]);
12759                           printf ("  p = 0x%x,", p);
12760                           printf ("  sz = 0x%x,", sz);
12761                           printf ("  rdst = 0x%x,", rdst);
12762                           printf ("  rsrc = 0x%x\n", rsrc);
12763                         }
12764                       SYNTAX("mov%s     %1, %0");
12765 #line 369 "rx-decode.opc"
12766                       ID(mov); sBWL (sz); SR(rsrc); F_____;
12767                       OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0);
12768
12769                     }
12770                   break;
12771               }
12772             break;
12773           case 0x21:
12774               GETBYTE ();
12775               switch (op[2] & 0x00)
12776               {
12777                 case 0x00:
12778                   goto op_semantics_102;
12779                   break;
12780               }
12781             break;
12782           case 0x22:
12783               GETBYTE ();
12784               switch (op[2] & 0x00)
12785               {
12786                 case 0x00:
12787                   goto op_semantics_102;
12788                   break;
12789               }
12790             break;
12791           case 0x24:
12792               GETBYTE ();
12793               switch (op[2] & 0x00)
12794               {
12795                 case 0x00:
12796                   goto op_semantics_102;
12797                   break;
12798               }
12799             break;
12800           case 0x25:
12801               GETBYTE ();
12802               switch (op[2] & 0x00)
12803               {
12804                 case 0x00:
12805                   goto op_semantics_102;
12806                   break;
12807               }
12808             break;
12809           case 0x26:
12810               GETBYTE ();
12811               switch (op[2] & 0x00)
12812               {
12813                 case 0x00:
12814                   goto op_semantics_102;
12815                   break;
12816               }
12817             break;
12818           case 0x27:
12819               GETBYTE ();
12820               switch (op[2] & 0x00)
12821               {
12822                 case 0x00:
12823                     {
12824                       /** 1111 1101 0010 0111 rdst rsrc movco   %1, [%0] */
12825 #line 1071 "rx-decode.opc"
12826                       int rdst AU = (op[2] >> 4) & 0x0f;
12827 #line 1071 "rx-decode.opc"
12828                       int rsrc AU = op[2] & 0x0f;
12829                       if (trace)
12830                         {
12831                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12832                                  "/** 1111 1101 0010 0111 rdst rsrc     movco   %1, [%0] */",
12833                                  op[0], op[1], op[2]);
12834                           printf ("  rdst = 0x%x,", rdst);
12835                           printf ("  rsrc = 0x%x\n", rsrc);
12836                         }
12837                       SYNTAX("movco     %1, [%0]");
12838 #line 1071 "rx-decode.opc"
12839                        ID(movco); SR(rsrc); DR(rdst); F_____;
12840
12841                     }
12842                   break;
12843               }
12844             break;
12845           case 0x28:
12846               GETBYTE ();
12847               switch (op[2] & 0x00)
12848               {
12849                 case 0x00:
12850                   op_semantics_103:
12851                     {
12852                       /** 1111 1101 0010 1p sz rsrc rdst        mov%s   %1, %0 */
12853 #line 373 "rx-decode.opc"
12854                       int p AU = (op[1] >> 2) & 0x01;
12855 #line 373 "rx-decode.opc"
12856                       int sz AU = op[1] & 0x03;
12857 #line 373 "rx-decode.opc"
12858                       int rsrc AU = (op[2] >> 4) & 0x0f;
12859 #line 373 "rx-decode.opc"
12860                       int rdst AU = op[2] & 0x0f;
12861                       if (trace)
12862                         {
12863                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12864                                  "/** 1111 1101 0010 1p sz rsrc rdst    mov%s   %1, %0 */",
12865                                  op[0], op[1], op[2]);
12866                           printf ("  p = 0x%x,", p);
12867                           printf ("  sz = 0x%x,", sz);
12868                           printf ("  rsrc = 0x%x,", rsrc);
12869                           printf ("  rdst = 0x%x\n", rdst);
12870                         }
12871                       SYNTAX("mov%s     %1, %0");
12872 #line 373 "rx-decode.opc"
12873                       ID(mov); sBWL (sz); DR(rdst); F_____;
12874                       OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12875
12876                     }
12877                   break;
12878               }
12879             break;
12880           case 0x29:
12881               GETBYTE ();
12882               switch (op[2] & 0x00)
12883               {
12884                 case 0x00:
12885                   goto op_semantics_103;
12886                   break;
12887               }
12888             break;
12889           case 0x2a:
12890               GETBYTE ();
12891               switch (op[2] & 0x00)
12892               {
12893                 case 0x00:
12894                   goto op_semantics_103;
12895                   break;
12896               }
12897             break;
12898           case 0x2c:
12899               GETBYTE ();
12900               switch (op[2] & 0x00)
12901               {
12902                 case 0x00:
12903                   goto op_semantics_103;
12904                   break;
12905               }
12906             break;
12907           case 0x2d:
12908               GETBYTE ();
12909               switch (op[2] & 0x00)
12910               {
12911                 case 0x00:
12912                   goto op_semantics_103;
12913                   break;
12914               }
12915             break;
12916           case 0x2e:
12917               GETBYTE ();
12918               switch (op[2] & 0x00)
12919               {
12920                 case 0x00:
12921                   goto op_semantics_103;
12922                   break;
12923               }
12924             break;
12925           case 0x2f:
12926               GETBYTE ();
12927               switch (op[2] & 0x00)
12928               {
12929                 case 0x00:
12930                     {
12931                       /** 1111 1101 0010 1111 rsrc rdst movli   [%1], %0 */
12932 #line 1074 "rx-decode.opc"
12933                       int rsrc AU = (op[2] >> 4) & 0x0f;
12934 #line 1074 "rx-decode.opc"
12935                       int rdst AU = op[2] & 0x0f;
12936                       if (trace)
12937                         {
12938                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12939                                  "/** 1111 1101 0010 1111 rsrc rdst     movli   [%1], %0 */",
12940                                  op[0], op[1], op[2]);
12941                           printf ("  rsrc = 0x%x,", rsrc);
12942                           printf ("  rdst = 0x%x\n", rdst);
12943                         }
12944                       SYNTAX("movli     [%1], %0");
12945 #line 1074 "rx-decode.opc"
12946                        ID(movli); SR(rsrc); DR(rdst); F_____;
12947
12948                     }
12949                   break;
12950               }
12951             break;
12952           case 0x38:
12953               GETBYTE ();
12954               switch (op[2] & 0x00)
12955               {
12956                 case 0x00:
12957                   op_semantics_104:
12958                     {
12959                       /** 1111 1101 0011 1p sz rsrc rdst        movu%s  %1, %0 */
12960 #line 383 "rx-decode.opc"
12961                       int p AU = (op[1] >> 2) & 0x01;
12962 #line 383 "rx-decode.opc"
12963                       int sz AU = op[1] & 0x03;
12964 #line 383 "rx-decode.opc"
12965                       int rsrc AU = (op[2] >> 4) & 0x0f;
12966 #line 383 "rx-decode.opc"
12967                       int rdst AU = op[2] & 0x0f;
12968                       if (trace)
12969                         {
12970                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
12971                                  "/** 1111 1101 0011 1p sz rsrc rdst    movu%s  %1, %0 */",
12972                                  op[0], op[1], op[2]);
12973                           printf ("  p = 0x%x,", p);
12974                           printf ("  sz = 0x%x,", sz);
12975                           printf ("  rsrc = 0x%x,", rsrc);
12976                           printf ("  rdst = 0x%x\n", rdst);
12977                         }
12978                       SYNTAX("movu%s    %1, %0");
12979 #line 383 "rx-decode.opc"
12980                       ID(mov); uBW (sz); DR(rdst); F_____;
12981                        OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0);
12982
12983                     /*----------------------------------------------------------------------*/
12984                     /* PUSH/POP                                                         */
12985
12986                     }
12987                   break;
12988               }
12989             break;
12990           case 0x39:
12991               GETBYTE ();
12992               switch (op[2] & 0x00)
12993               {
12994                 case 0x00:
12995                   goto op_semantics_104;
12996                   break;
12997               }
12998             break;
12999           case 0x3a:
13000               GETBYTE ();
13001               switch (op[2] & 0x00)
13002               {
13003                 case 0x00:
13004                   goto op_semantics_104;
13005                   break;
13006               }
13007             break;
13008           case 0x3c:
13009               GETBYTE ();
13010               switch (op[2] & 0x00)
13011               {
13012                 case 0x00:
13013                   goto op_semantics_104;
13014                   break;
13015               }
13016             break;
13017           case 0x3d:
13018               GETBYTE ();
13019               switch (op[2] & 0x00)
13020               {
13021                 case 0x00:
13022                   goto op_semantics_104;
13023                   break;
13024               }
13025             break;
13026           case 0x3e:
13027               GETBYTE ();
13028               switch (op[2] & 0x00)
13029               {
13030                 case 0x00:
13031                   goto op_semantics_104;
13032                   break;
13033               }
13034             break;
13035           case 0x44:
13036               GETBYTE ();
13037               switch (op[2] & 0x00)
13038               {
13039                 case 0x00:
13040                   op_semantics_105:
13041                     {
13042                       /** 1111 1101 0100 a100 srca srcb msbhi   %1, %2, %0 */
13043 #line 1095 "rx-decode.opc"
13044                       int a AU = (op[1] >> 3) & 0x01;
13045 #line 1095 "rx-decode.opc"
13046                       int srca AU = (op[2] >> 4) & 0x0f;
13047 #line 1095 "rx-decode.opc"
13048                       int srcb AU = op[2] & 0x0f;
13049                       if (trace)
13050                         {
13051                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13052                                  "/** 1111 1101 0100 a100 srca srcb     msbhi   %1, %2, %0 */",
13053                                  op[0], op[1], op[2]);
13054                           printf ("  a = 0x%x,", a);
13055                           printf ("  srca = 0x%x,", srca);
13056                           printf ("  srcb = 0x%x\n", srcb);
13057                         }
13058                       SYNTAX("msbhi     %1, %2, %0");
13059 #line 1095 "rx-decode.opc"
13060                       ID(msbhi); DR(a+32); SR(srca); S2R(srcb); F_____;
13061
13062                     }
13063                   break;
13064               }
13065             break;
13066           case 0x45:
13067               GETBYTE ();
13068               switch (op[2] & 0x00)
13069               {
13070                 case 0x00:
13071                   op_semantics_106:
13072                     {
13073                       /** 1111 1101 0100 a101 srca srcb msblo   %1, %2, %0 */
13074 #line 1101 "rx-decode.opc"
13075                       int a AU = (op[1] >> 3) & 0x01;
13076 #line 1101 "rx-decode.opc"
13077                       int srca AU = (op[2] >> 4) & 0x0f;
13078 #line 1101 "rx-decode.opc"
13079                       int srcb AU = op[2] & 0x0f;
13080                       if (trace)
13081                         {
13082                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13083                                  "/** 1111 1101 0100 a101 srca srcb     msblo   %1, %2, %0 */",
13084                                  op[0], op[1], op[2]);
13085                           printf ("  a = 0x%x,", a);
13086                           printf ("  srca = 0x%x,", srca);
13087                           printf ("  srcb = 0x%x\n", srcb);
13088                         }
13089                       SYNTAX("msblo     %1, %2, %0");
13090 #line 1101 "rx-decode.opc"
13091                       ID(msblo); DR(a+32); SR(srca); S2R(srcb); F_____;
13092
13093                     }
13094                   break;
13095               }
13096             break;
13097           case 0x46:
13098               GETBYTE ();
13099               switch (op[2] & 0x00)
13100               {
13101                 case 0x00:
13102                   op_semantics_107:
13103                     {
13104                       /** 1111 1101 0100 a110 srca srcb msblh   %1, %2, %0 */
13105 #line 1098 "rx-decode.opc"
13106                       int a AU = (op[1] >> 3) & 0x01;
13107 #line 1098 "rx-decode.opc"
13108                       int srca AU = (op[2] >> 4) & 0x0f;
13109 #line 1098 "rx-decode.opc"
13110                       int srcb AU = op[2] & 0x0f;
13111                       if (trace)
13112                         {
13113                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13114                                  "/** 1111 1101 0100 a110 srca srcb     msblh   %1, %2, %0 */",
13115                                  op[0], op[1], op[2]);
13116                           printf ("  a = 0x%x,", a);
13117                           printf ("  srca = 0x%x,", srca);
13118                           printf ("  srcb = 0x%x\n", srcb);
13119                         }
13120                       SYNTAX("msblh     %1, %2, %0");
13121 #line 1098 "rx-decode.opc"
13122                       ID(msblh); DR(a+32); SR(srca); S2R(srcb); F_____;
13123
13124                     }
13125                   break;
13126               }
13127             break;
13128           case 0x47:
13129               GETBYTE ();
13130               switch (op[2] & 0x00)
13131               {
13132                 case 0x00:
13133                   op_semantics_108:
13134                     {
13135                       /** 1111 1101 0100 a111 srca srcb         emsba   %1, %2, %0 */
13136 #line 1086 "rx-decode.opc"
13137                       int a AU = (op[1] >> 3) & 0x01;
13138 #line 1086 "rx-decode.opc"
13139                       int srca AU = (op[2] >> 4) & 0x0f;
13140 #line 1086 "rx-decode.opc"
13141                       int srcb AU = op[2] & 0x0f;
13142                       if (trace)
13143                         {
13144                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13145                                  "/** 1111 1101 0100 a111 srca srcb     emsba   %1, %2, %0 */",
13146                                  op[0], op[1], op[2]);
13147                           printf ("  a = 0x%x,", a);
13148                           printf ("  srca = 0x%x,", srca);
13149                           printf ("  srcb = 0x%x\n", srcb);
13150                         }
13151                       SYNTAX("emsba     %1, %2, %0");
13152 #line 1086 "rx-decode.opc"
13153                       ID(emsba); DR(a+32); SR(srca); S2R(srcb); F_____;
13154
13155                     }
13156                   break;
13157               }
13158             break;
13159           case 0x4c:
13160               GETBYTE ();
13161               switch (op[2] & 0x00)
13162               {
13163                 case 0x00:
13164                   goto op_semantics_105;
13165                   break;
13166               }
13167             break;
13168           case 0x4d:
13169               GETBYTE ();
13170               switch (op[2] & 0x00)
13171               {
13172                 case 0x00:
13173                   goto op_semantics_106;
13174                   break;
13175               }
13176             break;
13177           case 0x4e:
13178               GETBYTE ();
13179               switch (op[2] & 0x00)
13180               {
13181                 case 0x00:
13182                   goto op_semantics_107;
13183                   break;
13184               }
13185             break;
13186           case 0x4f:
13187               GETBYTE ();
13188               switch (op[2] & 0x00)
13189               {
13190                 case 0x00:
13191                   goto op_semantics_108;
13192                   break;
13193               }
13194             break;
13195           case 0x60:
13196               GETBYTE ();
13197               switch (op[2] & 0x00)
13198               {
13199                 case 0x00:
13200                     {
13201                       /** 1111 1101 0110 0000 rsrc rdst shlr    %2, %0 */
13202 #line 754 "rx-decode.opc"
13203                       int rsrc AU = (op[2] >> 4) & 0x0f;
13204 #line 754 "rx-decode.opc"
13205                       int rdst AU = op[2] & 0x0f;
13206                       if (trace)
13207                         {
13208                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13209                                  "/** 1111 1101 0110 0000 rsrc rdst     shlr    %2, %0 */",
13210                                  op[0], op[1], op[2]);
13211                           printf ("  rsrc = 0x%x,", rsrc);
13212                           printf ("  rdst = 0x%x\n", rdst);
13213                         }
13214                       SYNTAX("shlr      %2, %0");
13215 #line 754 "rx-decode.opc"
13216                       ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
13217
13218                     }
13219                   break;
13220               }
13221             break;
13222           case 0x61:
13223               GETBYTE ();
13224               switch (op[2] & 0x00)
13225               {
13226                 case 0x00:
13227                     {
13228                       /** 1111 1101 0110 0001 rsrc rdst shar    %2, %0 */
13229 #line 744 "rx-decode.opc"
13230                       int rsrc AU = (op[2] >> 4) & 0x0f;
13231 #line 744 "rx-decode.opc"
13232                       int rdst AU = op[2] & 0x0f;
13233                       if (trace)
13234                         {
13235                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13236                                  "/** 1111 1101 0110 0001 rsrc rdst     shar    %2, %0 */",
13237                                  op[0], op[1], op[2]);
13238                           printf ("  rsrc = 0x%x,", rsrc);
13239                           printf ("  rdst = 0x%x\n", rdst);
13240                         }
13241                       SYNTAX("shar      %2, %0");
13242 #line 744 "rx-decode.opc"
13243                       ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
13244
13245                     }
13246                   break;
13247               }
13248             break;
13249           case 0x62:
13250               GETBYTE ();
13251               switch (op[2] & 0x00)
13252               {
13253                 case 0x00:
13254                     {
13255                       /** 1111 1101 0110 0010 rsrc rdst shll    %2, %0 */
13256 #line 734 "rx-decode.opc"
13257                       int rsrc AU = (op[2] >> 4) & 0x0f;
13258 #line 734 "rx-decode.opc"
13259                       int rdst AU = op[2] & 0x0f;
13260                       if (trace)
13261                         {
13262                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13263                                  "/** 1111 1101 0110 0010 rsrc rdst     shll    %2, %0 */",
13264                                  op[0], op[1], op[2]);
13265                           printf ("  rsrc = 0x%x,", rsrc);
13266                           printf ("  rdst = 0x%x\n", rdst);
13267                         }
13268                       SYNTAX("shll      %2, %0");
13269 #line 734 "rx-decode.opc"
13270                       ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
13271
13272                     }
13273                   break;
13274               }
13275             break;
13276           case 0x64:
13277               GETBYTE ();
13278               switch (op[2] & 0x00)
13279               {
13280                 case 0x00:
13281                     {
13282                       /** 1111 1101 0110 0100 rsrc rdst rotr    %1, %0 */
13283 #line 778 "rx-decode.opc"
13284                       int rsrc AU = (op[2] >> 4) & 0x0f;
13285 #line 778 "rx-decode.opc"
13286                       int rdst AU = op[2] & 0x0f;
13287                       if (trace)
13288                         {
13289                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13290                                  "/** 1111 1101 0110 0100 rsrc rdst     rotr    %1, %0 */",
13291                                  op[0], op[1], op[2]);
13292                           printf ("  rsrc = 0x%x,", rsrc);
13293                           printf ("  rdst = 0x%x\n", rdst);
13294                         }
13295                       SYNTAX("rotr      %1, %0");
13296 #line 778 "rx-decode.opc"
13297                       ID(rotr); SR(rsrc); DR(rdst); F__SZC;
13298
13299                     }
13300                   break;
13301               }
13302             break;
13303           case 0x65:
13304               GETBYTE ();
13305               switch (op[2] & 0x00)
13306               {
13307                 case 0x00:
13308                     {
13309                       /** 1111 1101 0110 0101 rsrc rdst revw    %1, %0 */
13310 #line 781 "rx-decode.opc"
13311                       int rsrc AU = (op[2] >> 4) & 0x0f;
13312 #line 781 "rx-decode.opc"
13313                       int rdst AU = op[2] & 0x0f;
13314                       if (trace)
13315                         {
13316                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13317                                  "/** 1111 1101 0110 0101 rsrc rdst     revw    %1, %0 */",
13318                                  op[0], op[1], op[2]);
13319                           printf ("  rsrc = 0x%x,", rsrc);
13320                           printf ("  rdst = 0x%x\n", rdst);
13321                         }
13322                       SYNTAX("revw      %1, %0");
13323 #line 781 "rx-decode.opc"
13324                       ID(revw); SR(rsrc); DR(rdst);
13325
13326                     }
13327                   break;
13328               }
13329             break;
13330           case 0x66:
13331               GETBYTE ();
13332               switch (op[2] & 0x00)
13333               {
13334                 case 0x00:
13335                     {
13336                       /** 1111 1101 0110 0110 rsrc rdst rotl    %1, %0 */
13337 #line 772 "rx-decode.opc"
13338                       int rsrc AU = (op[2] >> 4) & 0x0f;
13339 #line 772 "rx-decode.opc"
13340                       int rdst AU = op[2] & 0x0f;
13341                       if (trace)
13342                         {
13343                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13344                                  "/** 1111 1101 0110 0110 rsrc rdst     rotl    %1, %0 */",
13345                                  op[0], op[1], op[2]);
13346                           printf ("  rsrc = 0x%x,", rsrc);
13347                           printf ("  rdst = 0x%x\n", rdst);
13348                         }
13349                       SYNTAX("rotl      %1, %0");
13350 #line 772 "rx-decode.opc"
13351                       ID(rotl); SR(rsrc); DR(rdst); F__SZC;
13352
13353                     }
13354                   break;
13355               }
13356             break;
13357           case 0x67:
13358               GETBYTE ();
13359               switch (op[2] & 0x00)
13360               {
13361                 case 0x00:
13362                     {
13363                       /** 1111 1101 0110 0111 rsrc rdst revl    %1, %0 */
13364 #line 784 "rx-decode.opc"
13365                       int rsrc AU = (op[2] >> 4) & 0x0f;
13366 #line 784 "rx-decode.opc"
13367                       int rdst AU = op[2] & 0x0f;
13368                       if (trace)
13369                         {
13370                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13371                                  "/** 1111 1101 0110 0111 rsrc rdst     revl    %1, %0 */",
13372                                  op[0], op[1], op[2]);
13373                           printf ("  rsrc = 0x%x,", rsrc);
13374                           printf ("  rdst = 0x%x\n", rdst);
13375                         }
13376                       SYNTAX("revl      %1, %0");
13377 #line 784 "rx-decode.opc"
13378                       ID(revl); SR(rsrc); DR(rdst);
13379
13380                     /*----------------------------------------------------------------------*/
13381                     /* BRANCH                                                           */
13382
13383                     }
13384                   break;
13385               }
13386             break;
13387           case 0x68:
13388               GETBYTE ();
13389               switch (op[2] & 0x00)
13390               {
13391                 case 0x00:
13392                   op_semantics_109:
13393                     {
13394                       /** 1111 1101 0110 100c rsrc rdst mvtc    %1, %0 */
13395 #line 1035 "rx-decode.opc"
13396                       int c AU = op[1] & 0x01;
13397 #line 1035 "rx-decode.opc"
13398                       int rsrc AU = (op[2] >> 4) & 0x0f;
13399 #line 1035 "rx-decode.opc"
13400                       int rdst AU = op[2] & 0x0f;
13401                       if (trace)
13402                         {
13403                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13404                                  "/** 1111 1101 0110 100c rsrc rdst     mvtc    %1, %0 */",
13405                                  op[0], op[1], op[2]);
13406                           printf ("  c = 0x%x,", c);
13407                           printf ("  rsrc = 0x%x,", rsrc);
13408                           printf ("  rdst = 0x%x\n", rdst);
13409                         }
13410                       SYNTAX("mvtc      %1, %0");
13411 #line 1035 "rx-decode.opc"
13412                       ID(mov); SR(rsrc); DR(c*16+rdst + 16);
13413
13414                     }
13415                   break;
13416               }
13417             break;
13418           case 0x69:
13419               GETBYTE ();
13420               switch (op[2] & 0x00)
13421               {
13422                 case 0x00:
13423                   goto op_semantics_109;
13424                   break;
13425               }
13426             break;
13427           case 0x6a:
13428               GETBYTE ();
13429               switch (op[2] & 0x00)
13430               {
13431                 case 0x00:
13432                   op_semantics_110:
13433                     {
13434                       /** 1111 1101 0110 101s rsrc rdst mvfc    %1, %0 */
13435 #line 1038 "rx-decode.opc"
13436                       int s AU = op[1] & 0x01;
13437 #line 1038 "rx-decode.opc"
13438                       int rsrc AU = (op[2] >> 4) & 0x0f;
13439 #line 1038 "rx-decode.opc"
13440                       int rdst AU = op[2] & 0x0f;
13441                       if (trace)
13442                         {
13443                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13444                                  "/** 1111 1101 0110 101s rsrc rdst     mvfc    %1, %0 */",
13445                                  op[0], op[1], op[2]);
13446                           printf ("  s = 0x%x,", s);
13447                           printf ("  rsrc = 0x%x,", rsrc);
13448                           printf ("  rdst = 0x%x\n", rdst);
13449                         }
13450                       SYNTAX("mvfc      %1, %0");
13451 #line 1038 "rx-decode.opc"
13452                       ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
13453
13454                     /*----------------------------------------------------------------------*/
13455                     /* INTERRUPTS                                                               */
13456
13457                     }
13458                   break;
13459               }
13460             break;
13461           case 0x6b:
13462               GETBYTE ();
13463               switch (op[2] & 0x00)
13464               {
13465                 case 0x00:
13466                   goto op_semantics_110;
13467                   break;
13468               }
13469             break;
13470           case 0x6c:
13471               GETBYTE ();
13472               switch (op[2] & 0x00)
13473               {
13474                 case 0x00:
13475                   op_semantics_111:
13476                     {
13477                       /** 1111 1101 0110 110i mmmm rdst rotr    #%1, %0 */
13478 #line 775 "rx-decode.opc"
13479                       int i AU = op[1] & 0x01;
13480 #line 775 "rx-decode.opc"
13481                       int mmmm AU = (op[2] >> 4) & 0x0f;
13482 #line 775 "rx-decode.opc"
13483                       int rdst AU = op[2] & 0x0f;
13484                       if (trace)
13485                         {
13486                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13487                                  "/** 1111 1101 0110 110i mmmm rdst     rotr    #%1, %0 */",
13488                                  op[0], op[1], op[2]);
13489                           printf ("  i = 0x%x,", i);
13490                           printf ("  mmmm = 0x%x,", mmmm);
13491                           printf ("  rdst = 0x%x\n", rdst);
13492                         }
13493                       SYNTAX("rotr      #%1, %0");
13494 #line 775 "rx-decode.opc"
13495                       ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
13496
13497                     }
13498                   break;
13499               }
13500             break;
13501           case 0x6d:
13502               GETBYTE ();
13503               switch (op[2] & 0x00)
13504               {
13505                 case 0x00:
13506                   goto op_semantics_111;
13507                   break;
13508               }
13509             break;
13510           case 0x6e:
13511               GETBYTE ();
13512               switch (op[2] & 0x00)
13513               {
13514                 case 0x00:
13515                   op_semantics_112:
13516                     {
13517                       /** 1111 1101 0110 111i mmmm rdst rotl    #%1, %0 */
13518 #line 769 "rx-decode.opc"
13519                       int i AU = op[1] & 0x01;
13520 #line 769 "rx-decode.opc"
13521                       int mmmm AU = (op[2] >> 4) & 0x0f;
13522 #line 769 "rx-decode.opc"
13523                       int rdst AU = op[2] & 0x0f;
13524                       if (trace)
13525                         {
13526                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13527                                  "/** 1111 1101 0110 111i mmmm rdst     rotl    #%1, %0 */",
13528                                  op[0], op[1], op[2]);
13529                           printf ("  i = 0x%x,", i);
13530                           printf ("  mmmm = 0x%x,", mmmm);
13531                           printf ("  rdst = 0x%x\n", rdst);
13532                         }
13533                       SYNTAX("rotl      #%1, %0");
13534 #line 769 "rx-decode.opc"
13535                       ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
13536
13537                     }
13538                   break;
13539               }
13540             break;
13541           case 0x6f:
13542               GETBYTE ();
13543               switch (op[2] & 0x00)
13544               {
13545                 case 0x00:
13546                   goto op_semantics_112;
13547                   break;
13548               }
13549             break;
13550           case 0x70:
13551               GETBYTE ();
13552               switch (op[2] & 0xf0)
13553               {
13554                 case 0x20:
13555                   op_semantics_113:
13556                     {
13557                       /** 1111 1101 0111 im00 0010rdst  adc     #%1, %0 */
13558 #line 513 "rx-decode.opc"
13559                       int im AU = (op[1] >> 2) & 0x03;
13560 #line 513 "rx-decode.opc"
13561                       int rdst AU = op[2] & 0x0f;
13562                       if (trace)
13563                         {
13564                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13565                                  "/** 1111 1101 0111 im00 0010rdst      adc     #%1, %0 */",
13566                                  op[0], op[1], op[2]);
13567                           printf ("  im = 0x%x,", im);
13568                           printf ("  rdst = 0x%x\n", rdst);
13569                         }
13570                       SYNTAX("adc       #%1, %0");
13571 #line 513 "rx-decode.opc"
13572                       ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
13573
13574                     }
13575                   break;
13576                 case 0x40:
13577                   op_semantics_114:
13578                     {
13579                       /** 1111 1101 0111 im00 0100rdst  max     #%1, %0 */
13580 #line 595 "rx-decode.opc"
13581                       int im AU = (op[1] >> 2) & 0x03;
13582 #line 595 "rx-decode.opc"
13583                       int rdst AU = op[2] & 0x0f;
13584                       if (trace)
13585                         {
13586                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13587                                  "/** 1111 1101 0111 im00 0100rdst      max     #%1, %0 */",
13588                                  op[0], op[1], op[2]);
13589                           printf ("  im = 0x%x,", im);
13590                           printf ("  rdst = 0x%x\n", rdst);
13591                         }
13592                       SYNTAX("max       #%1, %0");
13593 #line 595 "rx-decode.opc"
13594                       int val = IMMex (im);
13595                       if (im == 0 && (unsigned) val == 0x80000000 && rdst == 0)
13596                         {
13597                           ID (nop7);
13598                           SYNTAX("nop\t; max\t#0x80000000, r0");
13599                         }
13600                       else
13601                         {
13602                           ID(max);
13603                         }
13604                       DR(rdst); SC(val);
13605
13606                     }
13607                   break;
13608                 case 0x50:
13609                   op_semantics_115:
13610                     {
13611                       /** 1111 1101 0111 im00 0101rdst  min     #%1, %0 */
13612 #line 625 "rx-decode.opc"
13613                       int im AU = (op[1] >> 2) & 0x03;
13614 #line 625 "rx-decode.opc"
13615                       int rdst AU = op[2] & 0x0f;
13616                       if (trace)
13617                         {
13618                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13619                                  "/** 1111 1101 0111 im00 0101rdst      min     #%1, %0 */",
13620                                  op[0], op[1], op[2]);
13621                           printf ("  im = 0x%x,", im);
13622                           printf ("  rdst = 0x%x\n", rdst);
13623                         }
13624                       SYNTAX("min       #%1, %0");
13625 #line 625 "rx-decode.opc"
13626                       ID(min); DR(rdst); SC(IMMex(im));
13627
13628                     }
13629                   break;
13630                 case 0x60:
13631                   op_semantics_116:
13632                     {
13633                       /** 1111 1101 0111 im00 0110rdst  emul    #%1, %0 */
13634 #line 683 "rx-decode.opc"
13635                       int im AU = (op[1] >> 2) & 0x03;
13636 #line 683 "rx-decode.opc"
13637                       int rdst AU = op[2] & 0x0f;
13638                       if (trace)
13639                         {
13640                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13641                                  "/** 1111 1101 0111 im00 0110rdst      emul    #%1, %0 */",
13642                                  op[0], op[1], op[2]);
13643                           printf ("  im = 0x%x,", im);
13644                           printf ("  rdst = 0x%x\n", rdst);
13645                         }
13646                       SYNTAX("emul      #%1, %0");
13647 #line 683 "rx-decode.opc"
13648                       ID(emul); DR(rdst); SC(IMMex(im));
13649
13650                     }
13651                   break;
13652                 case 0x70:
13653                   op_semantics_117:
13654                     {
13655                       /** 1111 1101 0111 im00 0111rdst  emulu   #%1, %0 */
13656 #line 695 "rx-decode.opc"
13657                       int im AU = (op[1] >> 2) & 0x03;
13658 #line 695 "rx-decode.opc"
13659                       int rdst AU = op[2] & 0x0f;
13660                       if (trace)
13661                         {
13662                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13663                                  "/** 1111 1101 0111 im00 0111rdst      emulu   #%1, %0 */",
13664                                  op[0], op[1], op[2]);
13665                           printf ("  im = 0x%x,", im);
13666                           printf ("  rdst = 0x%x\n", rdst);
13667                         }
13668                       SYNTAX("emulu     #%1, %0");
13669 #line 695 "rx-decode.opc"
13670                       ID(emulu); DR(rdst); SC(IMMex(im));
13671
13672                     }
13673                   break;
13674                 case 0x80:
13675                   op_semantics_118:
13676                     {
13677                       /** 1111 1101 0111 im00 1000rdst  div     #%1, %0 */
13678 #line 707 "rx-decode.opc"
13679                       int im AU = (op[1] >> 2) & 0x03;
13680 #line 707 "rx-decode.opc"
13681                       int rdst AU = op[2] & 0x0f;
13682                       if (trace)
13683                         {
13684                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13685                                  "/** 1111 1101 0111 im00 1000rdst      div     #%1, %0 */",
13686                                  op[0], op[1], op[2]);
13687                           printf ("  im = 0x%x,", im);
13688                           printf ("  rdst = 0x%x\n", rdst);
13689                         }
13690                       SYNTAX("div       #%1, %0");
13691 #line 707 "rx-decode.opc"
13692                       ID(div); DR(rdst); SC(IMMex(im)); F_O___;
13693
13694                     }
13695                   break;
13696                 case 0x90:
13697                   op_semantics_119:
13698                     {
13699                       /** 1111 1101 0111 im00 1001rdst  divu    #%1, %0 */
13700 #line 719 "rx-decode.opc"
13701                       int im AU = (op[1] >> 2) & 0x03;
13702 #line 719 "rx-decode.opc"
13703                       int rdst AU = op[2] & 0x0f;
13704                       if (trace)
13705                         {
13706                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13707                                  "/** 1111 1101 0111 im00 1001rdst      divu    #%1, %0 */",
13708                                  op[0], op[1], op[2]);
13709                           printf ("  im = 0x%x,", im);
13710                           printf ("  rdst = 0x%x\n", rdst);
13711                         }
13712                       SYNTAX("divu      #%1, %0");
13713 #line 719 "rx-decode.opc"
13714                       ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
13715
13716                     }
13717                   break;
13718                 case 0xc0:
13719                   op_semantics_120:
13720                     {
13721                       /** 1111 1101 0111 im00 1100rdst  tst     #%1, %2 */
13722 #line 492 "rx-decode.opc"
13723                       int im AU = (op[1] >> 2) & 0x03;
13724 #line 492 "rx-decode.opc"
13725                       int rdst AU = op[2] & 0x0f;
13726                       if (trace)
13727                         {
13728                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13729                                  "/** 1111 1101 0111 im00 1100rdst      tst     #%1, %2 */",
13730                                  op[0], op[1], op[2]);
13731                           printf ("  im = 0x%x,", im);
13732                           printf ("  rdst = 0x%x\n", rdst);
13733                         }
13734                       SYNTAX("tst       #%1, %2");
13735 #line 492 "rx-decode.opc"
13736                       ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
13737
13738                     }
13739                   break;
13740                 case 0xd0:
13741                   op_semantics_121:
13742                     {
13743                       /** 1111 1101 0111 im00 1101rdst  xor     #%1, %0 */
13744 #line 471 "rx-decode.opc"
13745                       int im AU = (op[1] >> 2) & 0x03;
13746 #line 471 "rx-decode.opc"
13747                       int rdst AU = op[2] & 0x0f;
13748                       if (trace)
13749                         {
13750                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13751                                  "/** 1111 1101 0111 im00 1101rdst      xor     #%1, %0 */",
13752                                  op[0], op[1], op[2]);
13753                           printf ("  im = 0x%x,", im);
13754                           printf ("  rdst = 0x%x\n", rdst);
13755                         }
13756                       SYNTAX("xor       #%1, %0");
13757 #line 471 "rx-decode.opc"
13758                       ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
13759
13760                     }
13761                   break;
13762                 case 0xe0:
13763                   op_semantics_122:
13764                     {
13765                       /** 1111 1101 0111 im00 1110rdst  stz     #%1, %0 */
13766 #line 417 "rx-decode.opc"
13767                       int im AU = (op[1] >> 2) & 0x03;
13768 #line 417 "rx-decode.opc"
13769                       int rdst AU = op[2] & 0x0f;
13770                       if (trace)
13771                         {
13772                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13773                                  "/** 1111 1101 0111 im00 1110rdst      stz     #%1, %0 */",
13774                                  op[0], op[1], op[2]);
13775                           printf ("  im = 0x%x,", im);
13776                           printf ("  rdst = 0x%x\n", rdst);
13777                         }
13778                       SYNTAX("stz       #%1, %0");
13779 #line 417 "rx-decode.opc"
13780                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
13781
13782                     }
13783                   break;
13784                 case 0xf0:
13785                   op_semantics_123:
13786                     {
13787                       /** 1111 1101 0111 im00 1111rdst  stnz    #%1, %0 */
13788 #line 420 "rx-decode.opc"
13789                       int im AU = (op[1] >> 2) & 0x03;
13790 #line 420 "rx-decode.opc"
13791                       int rdst AU = op[2] & 0x0f;
13792                       if (trace)
13793                         {
13794                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13795                                  "/** 1111 1101 0111 im00 1111rdst      stnz    #%1, %0 */",
13796                                  op[0], op[1], op[2]);
13797                           printf ("  im = 0x%x,", im);
13798                           printf ("  rdst = 0x%x\n", rdst);
13799                         }
13800                       SYNTAX("stnz      #%1, %0");
13801 #line 420 "rx-decode.opc"
13802                       ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
13803
13804                     /*----------------------------------------------------------------------*/
13805                     /* RTSD                                                                     */
13806
13807                     }
13808                   break;
13809                 default: UNSUPPORTED(); break;
13810               }
13811             break;
13812           case 0x72:
13813               GETBYTE ();
13814               switch (op[2] & 0xf0)
13815               {
13816                 case 0x00:
13817                     {
13818                       /** 1111 1101 0111 0010 0000 rdst fsub    #%1, %0 */
13819 #line 927 "rx-decode.opc"
13820                       int rdst AU = op[2] & 0x0f;
13821                       if (trace)
13822                         {
13823                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13824                                  "/** 1111 1101 0111 0010 0000 rdst     fsub    #%1, %0 */",
13825                                  op[0], op[1], op[2]);
13826                           printf ("  rdst = 0x%x\n", rdst);
13827                         }
13828                       SYNTAX("fsub      #%1, %0");
13829 #line 927 "rx-decode.opc"
13830                       ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
13831
13832                     }
13833                   break;
13834                 case 0x10:
13835                     {
13836                       /** 1111 1101 0111 0010 0001 rdst fcmp    #%1, %0 */
13837 #line 921 "rx-decode.opc"
13838                       int rdst AU = op[2] & 0x0f;
13839                       if (trace)
13840                         {
13841                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13842                                  "/** 1111 1101 0111 0010 0001 rdst     fcmp    #%1, %0 */",
13843                                  op[0], op[1], op[2]);
13844                           printf ("  rdst = 0x%x\n", rdst);
13845                         }
13846                       SYNTAX("fcmp      #%1, %0");
13847 #line 921 "rx-decode.opc"
13848                       ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
13849
13850                     }
13851                   break;
13852                 case 0x20:
13853                     {
13854                       /** 1111 1101 0111 0010 0010 rdst fadd    #%1, %0 */
13855 #line 915 "rx-decode.opc"
13856                       int rdst AU = op[2] & 0x0f;
13857                       if (trace)
13858                         {
13859                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13860                                  "/** 1111 1101 0111 0010 0010 rdst     fadd    #%1, %0 */",
13861                                  op[0], op[1], op[2]);
13862                           printf ("  rdst = 0x%x\n", rdst);
13863                         }
13864                       SYNTAX("fadd      #%1, %0");
13865 #line 915 "rx-decode.opc"
13866                       ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
13867
13868                     }
13869                   break;
13870                 case 0x30:
13871                     {
13872                       /** 1111 1101 0111 0010 0011 rdst fmul    #%1, %0 */
13873 #line 936 "rx-decode.opc"
13874                       int rdst AU = op[2] & 0x0f;
13875                       if (trace)
13876                         {
13877                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13878                                  "/** 1111 1101 0111 0010 0011 rdst     fmul    #%1, %0 */",
13879                                  op[0], op[1], op[2]);
13880                           printf ("  rdst = 0x%x\n", rdst);
13881                         }
13882                       SYNTAX("fmul      #%1, %0");
13883 #line 936 "rx-decode.opc"
13884                       ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
13885
13886                     }
13887                   break;
13888                 case 0x40:
13889                     {
13890                       /** 1111 1101 0111 0010 0100 rdst fdiv    #%1, %0 */
13891 #line 942 "rx-decode.opc"
13892                       int rdst AU = op[2] & 0x0f;
13893                       if (trace)
13894                         {
13895                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13896                                  "/** 1111 1101 0111 0010 0100 rdst     fdiv    #%1, %0 */",
13897                                  op[0], op[1], op[2]);
13898                           printf ("  rdst = 0x%x\n", rdst);
13899                         }
13900                       SYNTAX("fdiv      #%1, %0");
13901 #line 942 "rx-decode.opc"
13902                       ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
13903
13904                     }
13905                   break;
13906                 default: UNSUPPORTED(); break;
13907               }
13908             break;
13909           case 0x73:
13910               GETBYTE ();
13911               switch (op[2] & 0xe0)
13912               {
13913                 case 0x00:
13914                   op_semantics_124:
13915                     {
13916                       /** 1111 1101 0111 im11 000crdst  mvtc    #%1, %0 */
13917 #line 1032 "rx-decode.opc"
13918                       int im AU = (op[1] >> 2) & 0x03;
13919 #line 1032 "rx-decode.opc"
13920                       int crdst AU = op[2] & 0x1f;
13921                       if (trace)
13922                         {
13923                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
13924                                  "/** 1111 1101 0111 im11 000crdst      mvtc    #%1, %0 */",
13925                                  op[0], op[1], op[2]);
13926                           printf ("  im = 0x%x,", im);
13927                           printf ("  crdst = 0x%x\n", crdst);
13928                         }
13929                       SYNTAX("mvtc      #%1, %0");
13930 #line 1032 "rx-decode.opc"
13931                       ID(mov); SC(IMMex(im)); DR(crdst + 16);
13932
13933                     }
13934                   break;
13935                 default: UNSUPPORTED(); break;
13936               }
13937             break;
13938           case 0x74:
13939               GETBYTE ();
13940               switch (op[2] & 0xf0)
13941               {
13942                 case 0x20:
13943                   goto op_semantics_113;
13944                   break;
13945                 case 0x40:
13946                   goto op_semantics_114;
13947                   break;
13948                 case 0x50:
13949                   goto op_semantics_115;
13950                   break;
13951                 case 0x60:
13952                   goto op_semantics_116;
13953                   break;
13954                 case 0x70:
13955                   goto op_semantics_117;
13956                   break;
13957                 case 0x80:
13958                   goto op_semantics_118;
13959                   break;
13960                 case 0x90:
13961                   goto op_semantics_119;
13962                   break;
13963                 case 0xc0:
13964                   goto op_semantics_120;
13965                   break;
13966                 case 0xd0:
13967                   goto op_semantics_121;
13968                   break;
13969                 case 0xe0:
13970                   goto op_semantics_122;
13971                   break;
13972                 case 0xf0:
13973                   goto op_semantics_123;
13974                   break;
13975                 default: UNSUPPORTED(); break;
13976               }
13977             break;
13978           case 0x75:
13979               GETBYTE ();
13980               switch (op[2] & 0xff)
13981               {
13982                 case 0x80:
13983                     GETBYTE ();
13984                     switch (op[3] & 0x0f)
13985                     {
13986                       case 0x00:
13987                         op_semantics_125:
13988                           {
13989                             /** 1111 1101 0111 0101 1000 rdst rsrc 0000 dmov.l  %1, %0 */
13990 #line 1176 "rx-decode.opc"
13991                             int rdst AU = op[2] & 0x0f;
13992 #line 1176 "rx-decode.opc"
13993                             int rsrc AU = (op[3] >> 4) & 0x0f;
13994                             if (trace)
13995                               {
13996                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
13997                                        "/** 1111 1101 0111 0101 1000 rdst rsrc 0000     dmov.l  %1, %0 */",
13998                                        op[0], op[1], op[2], op[3]);
13999                                 printf ("  rdst = 0x%x,", rdst);
14000                                 printf ("  rsrc = 0x%x\n", rsrc);
14001                               }
14002                             SYNTAX("dmov.l      %1, %0");
14003 #line 1176 "rx-decode.opc"
14004                             ID(dmov); DR(rdst); SDRL(rsrc); F_____;
14005
14006                           }
14007                         break;
14008                       case 0x02:
14009                         op_semantics_126:
14010                           {
14011                             /** 1111 1101 0111 0101 1000 rdst rsrc 0010 dmov.l  %1, %0 */
14012 #line 1173 "rx-decode.opc"
14013                             int rdst AU = op[2] & 0x0f;
14014 #line 1173 "rx-decode.opc"
14015                             int rsrc AU = (op[3] >> 4) & 0x0f;
14016                             if (trace)
14017                               {
14018                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14019                                        "/** 1111 1101 0111 0101 1000 rdst rsrc 0010     dmov.l  %1, %0 */",
14020                                        op[0], op[1], op[2], op[3]);
14021                                 printf ("  rdst = 0x%x,", rdst);
14022                                 printf ("  rsrc = 0x%x\n", rsrc);
14023                               }
14024                             SYNTAX("dmov.l      %1, %0");
14025 #line 1173 "rx-decode.opc"
14026                             ID(dmov); DR(rdst); SDRH(rsrc); F_____;
14027
14028                           }
14029                         break;
14030                       case 0x04:
14031                         op_semantics_127:
14032                           {
14033                             /** 1111 1101 0111 0101 1000 rdst rsrc 0100 mvfdc   %1, %0 */
14034 #line 1226 "rx-decode.opc"
14035                             int rdst AU = op[2] & 0x0f;
14036 #line 1226 "rx-decode.opc"
14037                             int rsrc AU = (op[3] >> 4) & 0x0f;
14038                             if (trace)
14039                               {
14040                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14041                                        "/** 1111 1101 0111 0101 1000 rdst rsrc 0100     mvfdc   %1, %0 */",
14042                                        op[0], op[1], op[2], op[3]);
14043                                 printf ("  rdst = 0x%x,", rdst);
14044                                 printf ("  rsrc = 0x%x\n", rsrc);
14045                               }
14046                             SYNTAX("mvfdc       %1, %0");
14047 #line 1226 "rx-decode.opc"
14048                             ID(mvfdc); DR(rdst); SCR(rsrc); F_____;
14049
14050                           }
14051                         break;
14052                       default: UNSUPPORTED(); break;
14053                     }
14054                   break;
14055                 case 0x81:
14056                     GETBYTE ();
14057                     switch (op[3] & 0x0f)
14058                     {
14059                       case 0x00:
14060                         goto op_semantics_125;
14061                         break;
14062                       case 0x02:
14063                         goto op_semantics_126;
14064                         break;
14065                       case 0x04:
14066                         goto op_semantics_127;
14067                         break;
14068                       default: UNSUPPORTED(); break;
14069                     }
14070                   break;
14071                 case 0x82:
14072                     GETBYTE ();
14073                     switch (op[3] & 0x0f)
14074                     {
14075                       case 0x00:
14076                         goto op_semantics_125;
14077                         break;
14078                       case 0x02:
14079                         goto op_semantics_126;
14080                         break;
14081                       case 0x04:
14082                         goto op_semantics_127;
14083                         break;
14084                       default: UNSUPPORTED(); break;
14085                     }
14086                   break;
14087                 case 0x83:
14088                     GETBYTE ();
14089                     switch (op[3] & 0x0f)
14090                     {
14091                       case 0x00:
14092                         goto op_semantics_125;
14093                         break;
14094                       case 0x02:
14095                         goto op_semantics_126;
14096                         break;
14097                       case 0x04:
14098                         goto op_semantics_127;
14099                         break;
14100                       default: UNSUPPORTED(); break;
14101                     }
14102                   break;
14103                 case 0x84:
14104                     GETBYTE ();
14105                     switch (op[3] & 0x0f)
14106                     {
14107                       case 0x00:
14108                         goto op_semantics_125;
14109                         break;
14110                       case 0x02:
14111                         goto op_semantics_126;
14112                         break;
14113                       case 0x04:
14114                         goto op_semantics_127;
14115                         break;
14116                       default: UNSUPPORTED(); break;
14117                     }
14118                   break;
14119                 case 0x85:
14120                     GETBYTE ();
14121                     switch (op[3] & 0x0f)
14122                     {
14123                       case 0x00:
14124                         goto op_semantics_125;
14125                         break;
14126                       case 0x02:
14127                         goto op_semantics_126;
14128                         break;
14129                       case 0x04:
14130                         goto op_semantics_127;
14131                         break;
14132                       default: UNSUPPORTED(); break;
14133                     }
14134                   break;
14135                 case 0x86:
14136                     GETBYTE ();
14137                     switch (op[3] & 0x0f)
14138                     {
14139                       case 0x00:
14140                         goto op_semantics_125;
14141                         break;
14142                       case 0x02:
14143                         goto op_semantics_126;
14144                         break;
14145                       case 0x04:
14146                         goto op_semantics_127;
14147                         break;
14148                       default: UNSUPPORTED(); break;
14149                     }
14150                   break;
14151                 case 0x87:
14152                     GETBYTE ();
14153                     switch (op[3] & 0x0f)
14154                     {
14155                       case 0x00:
14156                         goto op_semantics_125;
14157                         break;
14158                       case 0x02:
14159                         goto op_semantics_126;
14160                         break;
14161                       case 0x04:
14162                         goto op_semantics_127;
14163                         break;
14164                       default: UNSUPPORTED(); break;
14165                     }
14166                   break;
14167                 case 0x88:
14168                     GETBYTE ();
14169                     switch (op[3] & 0x0f)
14170                     {
14171                       case 0x00:
14172                         goto op_semantics_125;
14173                         break;
14174                       case 0x02:
14175                         goto op_semantics_126;
14176                         break;
14177                       case 0x04:
14178                         goto op_semantics_127;
14179                         break;
14180                       default: UNSUPPORTED(); break;
14181                     }
14182                   break;
14183                 case 0x89:
14184                     GETBYTE ();
14185                     switch (op[3] & 0x0f)
14186                     {
14187                       case 0x00:
14188                         goto op_semantics_125;
14189                         break;
14190                       case 0x02:
14191                         goto op_semantics_126;
14192                         break;
14193                       case 0x04:
14194                         goto op_semantics_127;
14195                         break;
14196                       default: UNSUPPORTED(); break;
14197                     }
14198                   break;
14199                 case 0x8a:
14200                     GETBYTE ();
14201                     switch (op[3] & 0x0f)
14202                     {
14203                       case 0x00:
14204                         goto op_semantics_125;
14205                         break;
14206                       case 0x02:
14207                         goto op_semantics_126;
14208                         break;
14209                       case 0x04:
14210                         goto op_semantics_127;
14211                         break;
14212                       default: UNSUPPORTED(); break;
14213                     }
14214                   break;
14215                 case 0x8b:
14216                     GETBYTE ();
14217                     switch (op[3] & 0x0f)
14218                     {
14219                       case 0x00:
14220                         goto op_semantics_125;
14221                         break;
14222                       case 0x02:
14223                         goto op_semantics_126;
14224                         break;
14225                       case 0x04:
14226                         goto op_semantics_127;
14227                         break;
14228                       default: UNSUPPORTED(); break;
14229                     }
14230                   break;
14231                 case 0x8c:
14232                     GETBYTE ();
14233                     switch (op[3] & 0x0f)
14234                     {
14235                       case 0x00:
14236                         goto op_semantics_125;
14237                         break;
14238                       case 0x02:
14239                         goto op_semantics_126;
14240                         break;
14241                       case 0x04:
14242                         goto op_semantics_127;
14243                         break;
14244                       default: UNSUPPORTED(); break;
14245                     }
14246                   break;
14247                 case 0x8d:
14248                     GETBYTE ();
14249                     switch (op[3] & 0x0f)
14250                     {
14251                       case 0x00:
14252                         goto op_semantics_125;
14253                         break;
14254                       case 0x02:
14255                         goto op_semantics_126;
14256                         break;
14257                       case 0x04:
14258                         goto op_semantics_127;
14259                         break;
14260                       default: UNSUPPORTED(); break;
14261                     }
14262                   break;
14263                 case 0x8e:
14264                     GETBYTE ();
14265                     switch (op[3] & 0x0f)
14266                     {
14267                       case 0x00:
14268                         goto op_semantics_125;
14269                         break;
14270                       case 0x02:
14271                         goto op_semantics_126;
14272                         break;
14273                       case 0x04:
14274                         goto op_semantics_127;
14275                         break;
14276                       default: UNSUPPORTED(); break;
14277                     }
14278                   break;
14279                 case 0x8f:
14280                     GETBYTE ();
14281                     switch (op[3] & 0x0f)
14282                     {
14283                       case 0x00:
14284                         goto op_semantics_125;
14285                         break;
14286                       case 0x02:
14287                         goto op_semantics_126;
14288                         break;
14289                       case 0x04:
14290                         goto op_semantics_127;
14291                         break;
14292                       default: UNSUPPORTED(); break;
14293                     }
14294                   break;
14295                 default: UNSUPPORTED(); break;
14296               }
14297             break;
14298           case 0x76:
14299               GETBYTE ();
14300               switch (op[2] & 0xff)
14301               {
14302                 case 0xc0:
14303                     GETBYTE ();
14304                     switch (op[3] & 0xff)
14305                     {
14306                       case 0x00:
14307                         op_semantics_128:
14308                           {
14309                             /** 1111 1101 0111 0110 1100 rsrc 0000 0000         save    %1 */
14310 #line 1161 "rx-decode.opc"
14311                             int rsrc AU = op[2] & 0x0f;
14312                             if (trace)
14313                               {
14314                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14315                                        "/** 1111 1101 0111 0110 1100 rsrc 0000 0000     save    %1 */",
14316                                        op[0], op[1], op[2], op[3]);
14317                                 printf ("  rsrc = 0x%x\n", rsrc);
14318                               }
14319                             SYNTAX("save        %1");
14320 #line 1161 "rx-decode.opc"
14321                             ID(save); SR(rsrc); F_____;
14322
14323                           }
14324                         break;
14325                       default: UNSUPPORTED(); break;
14326                     }
14327                   break;
14328                 case 0xc1:
14329                     GETBYTE ();
14330                     switch (op[3] & 0xff)
14331                     {
14332                       case 0x00:
14333                         goto op_semantics_128;
14334                         break;
14335                       default: UNSUPPORTED(); break;
14336                     }
14337                   break;
14338                 case 0xc2:
14339                     GETBYTE ();
14340                     switch (op[3] & 0xff)
14341                     {
14342                       case 0x00:
14343                         goto op_semantics_128;
14344                         break;
14345                       default: UNSUPPORTED(); break;
14346                     }
14347                   break;
14348                 case 0xc3:
14349                     GETBYTE ();
14350                     switch (op[3] & 0xff)
14351                     {
14352                       case 0x00:
14353                         goto op_semantics_128;
14354                         break;
14355                       default: UNSUPPORTED(); break;
14356                     }
14357                   break;
14358                 case 0xc4:
14359                     GETBYTE ();
14360                     switch (op[3] & 0xff)
14361                     {
14362                       case 0x00:
14363                         goto op_semantics_128;
14364                         break;
14365                       default: UNSUPPORTED(); break;
14366                     }
14367                   break;
14368                 case 0xc5:
14369                     GETBYTE ();
14370                     switch (op[3] & 0xff)
14371                     {
14372                       case 0x00:
14373                         goto op_semantics_128;
14374                         break;
14375                       default: UNSUPPORTED(); break;
14376                     }
14377                   break;
14378                 case 0xc6:
14379                     GETBYTE ();
14380                     switch (op[3] & 0xff)
14381                     {
14382                       case 0x00:
14383                         goto op_semantics_128;
14384                         break;
14385                       default: UNSUPPORTED(); break;
14386                     }
14387                   break;
14388                 case 0xc7:
14389                     GETBYTE ();
14390                     switch (op[3] & 0xff)
14391                     {
14392                       case 0x00:
14393                         goto op_semantics_128;
14394                         break;
14395                       default: UNSUPPORTED(); break;
14396                     }
14397                   break;
14398                 case 0xc8:
14399                     GETBYTE ();
14400                     switch (op[3] & 0xff)
14401                     {
14402                       case 0x00:
14403                         goto op_semantics_128;
14404                         break;
14405                       default: UNSUPPORTED(); break;
14406                     }
14407                   break;
14408                 case 0xc9:
14409                     GETBYTE ();
14410                     switch (op[3] & 0xff)
14411                     {
14412                       case 0x00:
14413                         goto op_semantics_128;
14414                         break;
14415                       default: UNSUPPORTED(); break;
14416                     }
14417                   break;
14418                 case 0xca:
14419                     GETBYTE ();
14420                     switch (op[3] & 0xff)
14421                     {
14422                       case 0x00:
14423                         goto op_semantics_128;
14424                         break;
14425                       default: UNSUPPORTED(); break;
14426                     }
14427                   break;
14428                 case 0xcb:
14429                     GETBYTE ();
14430                     switch (op[3] & 0xff)
14431                     {
14432                       case 0x00:
14433                         goto op_semantics_128;
14434                         break;
14435                       default: UNSUPPORTED(); break;
14436                     }
14437                   break;
14438                 case 0xcc:
14439                     GETBYTE ();
14440                     switch (op[3] & 0xff)
14441                     {
14442                       case 0x00:
14443                         goto op_semantics_128;
14444                         break;
14445                       default: UNSUPPORTED(); break;
14446                     }
14447                   break;
14448                 case 0xcd:
14449                     GETBYTE ();
14450                     switch (op[3] & 0xff)
14451                     {
14452                       case 0x00:
14453                         goto op_semantics_128;
14454                         break;
14455                       default: UNSUPPORTED(); break;
14456                     }
14457                   break;
14458                 case 0xce:
14459                     GETBYTE ();
14460                     switch (op[3] & 0xff)
14461                     {
14462                       case 0x00:
14463                         goto op_semantics_128;
14464                         break;
14465                       default: UNSUPPORTED(); break;
14466                     }
14467                   break;
14468                 case 0xcf:
14469                     GETBYTE ();
14470                     switch (op[3] & 0xff)
14471                     {
14472                       case 0x00:
14473                         goto op_semantics_128;
14474                         break;
14475                       default: UNSUPPORTED(); break;
14476                     }
14477                   break;
14478                 case 0xd0:
14479                     GETBYTE ();
14480                     switch (op[3] & 0xff)
14481                     {
14482                       case 0x00:
14483                         op_semantics_129:
14484                           {
14485                             /** 1111 1101 0111 0110 1101 rsrc 0000 0000         rstr    %1 */
14486 #line 1155 "rx-decode.opc"
14487                             int rsrc AU = op[2] & 0x0f;
14488                             if (trace)
14489                               {
14490                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14491                                        "/** 1111 1101 0111 0110 1101 rsrc 0000 0000     rstr    %1 */",
14492                                        op[0], op[1], op[2], op[3]);
14493                                 printf ("  rsrc = 0x%x\n", rsrc);
14494                               }
14495                             SYNTAX("rstr        %1");
14496 #line 1155 "rx-decode.opc"
14497                             ID(rstr); SR(rsrc); F_____;
14498
14499                           }
14500                         break;
14501                       default: UNSUPPORTED(); break;
14502                     }
14503                   break;
14504                 case 0xd1:
14505                     GETBYTE ();
14506                     switch (op[3] & 0xff)
14507                     {
14508                       case 0x00:
14509                         goto op_semantics_129;
14510                         break;
14511                       default: UNSUPPORTED(); break;
14512                     }
14513                   break;
14514                 case 0xd2:
14515                     GETBYTE ();
14516                     switch (op[3] & 0xff)
14517                     {
14518                       case 0x00:
14519                         goto op_semantics_129;
14520                         break;
14521                       default: UNSUPPORTED(); break;
14522                     }
14523                   break;
14524                 case 0xd3:
14525                     GETBYTE ();
14526                     switch (op[3] & 0xff)
14527                     {
14528                       case 0x00:
14529                         goto op_semantics_129;
14530                         break;
14531                       default: UNSUPPORTED(); break;
14532                     }
14533                   break;
14534                 case 0xd4:
14535                     GETBYTE ();
14536                     switch (op[3] & 0xff)
14537                     {
14538                       case 0x00:
14539                         goto op_semantics_129;
14540                         break;
14541                       default: UNSUPPORTED(); break;
14542                     }
14543                   break;
14544                 case 0xd5:
14545                     GETBYTE ();
14546                     switch (op[3] & 0xff)
14547                     {
14548                       case 0x00:
14549                         goto op_semantics_129;
14550                         break;
14551                       default: UNSUPPORTED(); break;
14552                     }
14553                   break;
14554                 case 0xd6:
14555                     GETBYTE ();
14556                     switch (op[3] & 0xff)
14557                     {
14558                       case 0x00:
14559                         goto op_semantics_129;
14560                         break;
14561                       default: UNSUPPORTED(); break;
14562                     }
14563                   break;
14564                 case 0xd7:
14565                     GETBYTE ();
14566                     switch (op[3] & 0xff)
14567                     {
14568                       case 0x00:
14569                         goto op_semantics_129;
14570                         break;
14571                       default: UNSUPPORTED(); break;
14572                     }
14573                   break;
14574                 case 0xd8:
14575                     GETBYTE ();
14576                     switch (op[3] & 0xff)
14577                     {
14578                       case 0x00:
14579                         goto op_semantics_129;
14580                         break;
14581                       default: UNSUPPORTED(); break;
14582                     }
14583                   break;
14584                 case 0xd9:
14585                     GETBYTE ();
14586                     switch (op[3] & 0xff)
14587                     {
14588                       case 0x00:
14589                         goto op_semantics_129;
14590                         break;
14591                       default: UNSUPPORTED(); break;
14592                     }
14593                   break;
14594                 case 0xda:
14595                     GETBYTE ();
14596                     switch (op[3] & 0xff)
14597                     {
14598                       case 0x00:
14599                         goto op_semantics_129;
14600                         break;
14601                       default: UNSUPPORTED(); break;
14602                     }
14603                   break;
14604                 case 0xdb:
14605                     GETBYTE ();
14606                     switch (op[3] & 0xff)
14607                     {
14608                       case 0x00:
14609                         goto op_semantics_129;
14610                         break;
14611                       default: UNSUPPORTED(); break;
14612                     }
14613                   break;
14614                 case 0xdc:
14615                     GETBYTE ();
14616                     switch (op[3] & 0xff)
14617                     {
14618                       case 0x00:
14619                         goto op_semantics_129;
14620                         break;
14621                       default: UNSUPPORTED(); break;
14622                     }
14623                   break;
14624                 case 0xdd:
14625                     GETBYTE ();
14626                     switch (op[3] & 0xff)
14627                     {
14628                       case 0x00:
14629                         goto op_semantics_129;
14630                         break;
14631                       default: UNSUPPORTED(); break;
14632                     }
14633                   break;
14634                 case 0xde:
14635                     GETBYTE ();
14636                     switch (op[3] & 0xff)
14637                     {
14638                       case 0x00:
14639                         goto op_semantics_129;
14640                         break;
14641                       default: UNSUPPORTED(); break;
14642                     }
14643                   break;
14644                 case 0xdf:
14645                     GETBYTE ();
14646                     switch (op[3] & 0xff)
14647                     {
14648                       case 0x00:
14649                         goto op_semantics_129;
14650                         break;
14651                       default: UNSUPPORTED(); break;
14652                     }
14653                   break;
14654                 case 0xe0:
14655                     {
14656                       /** 1111 1101 0111 0110 1110 0000 save    #%1 */
14657                       if (trace)
14658                         {
14659                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14660                                  "/** 1111 1101 0111 0110 1110 0000     save    #%1 */",
14661                                  op[0], op[1], op[2]);
14662                         }
14663                       SYNTAX("save      #%1");
14664 #line 1164 "rx-decode.opc"
14665                       ID(save); SC(IMM(1)); F_____;
14666
14667                     }
14668                   break;
14669                 case 0xf0:
14670                     {
14671                       /** 1111 1101 0111 0110 1111 0000         rstr    #%1 */
14672                       if (trace)
14673                         {
14674                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
14675                                  "/** 1111 1101 0111 0110 1111 0000     rstr    #%1 */",
14676                                  op[0], op[1], op[2]);
14677                         }
14678                       SYNTAX("rstr      #%1");
14679 #line 1158 "rx-decode.opc"
14680                       ID(rstr); SC(IMM(1)); F_____;
14681
14682                     }
14683                   break;
14684                 default: UNSUPPORTED(); break;
14685               }
14686             break;
14687           case 0x77:
14688               GETBYTE ();
14689               switch (op[2] & 0xff)
14690               {
14691                 case 0x00:
14692                 case 0x01:
14693                 case 0x02:
14694                 case 0x03:
14695                 case 0x04:
14696                 case 0x05:
14697                 case 0x06:
14698                 case 0x07:
14699                 case 0x08:
14700                 case 0x09:
14701                 case 0x0a:
14702                 case 0x0b:
14703                 case 0x0c:
14704                 case 0x0d:
14705                 case 0x0e:
14706                 case 0x0f:
14707                 case 0x10:
14708                 case 0x11:
14709                 case 0x12:
14710                 case 0x13:
14711                 case 0x14:
14712                 case 0x15:
14713                 case 0x16:
14714                 case 0x17:
14715                 case 0x18:
14716                 case 0x19:
14717                 case 0x1a:
14718                 case 0x1b:
14719                 case 0x1c:
14720                 case 0x1d:
14721                 case 0x1e:
14722                 case 0x1f:
14723                   goto op_semantics_124;
14724                   break;
14725                 case 0x80:
14726                     GETBYTE ();
14727                     switch (op[3] & 0x0f)
14728                     {
14729                       case 0x00:
14730                         op_semantics_130:
14731                           {
14732                             /** 1111 1101 0111 0111 1000 rsrc rdst 0000 dmov.l  %1, %0 */
14733 #line 1170 "rx-decode.opc"
14734                             int rsrc AU = op[2] & 0x0f;
14735 #line 1170 "rx-decode.opc"
14736                             int rdst AU = (op[3] >> 4) & 0x0f;
14737                             if (trace)
14738                               {
14739                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14740                                        "/** 1111 1101 0111 0111 1000 rsrc rdst 0000     dmov.l  %1, %0 */",
14741                                        op[0], op[1], op[2], op[3]);
14742                                 printf ("  rsrc = 0x%x,", rsrc);
14743                                 printf ("  rdst = 0x%x\n", rdst);
14744                               }
14745                             SYNTAX("dmov.l      %1, %0");
14746 #line 1170 "rx-decode.opc"
14747                             ID(dmov); DDRL(rdst); SR(rsrc); F_____;
14748
14749                           }
14750                         break;
14751                       case 0x02:
14752                       case 0x03:
14753                         op_semantics_131:
14754                           {
14755                             /** 1111 1101 0111 0111 1000 rsrc rdst 001s dmov%s  %1, %0 */
14756 #line 1167 "rx-decode.opc"
14757                             int rsrc AU = op[2] & 0x0f;
14758 #line 1167 "rx-decode.opc"
14759                             int rdst AU = (op[3] >> 4) & 0x0f;
14760 #line 1167 "rx-decode.opc"
14761                             int s AU = op[3] & 0x01;
14762                             if (trace)
14763                               {
14764                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14765                                        "/** 1111 1101 0111 0111 1000 rsrc rdst 001s     dmov%s  %1, %0 */",
14766                                        op[0], op[1], op[2], op[3]);
14767                                 printf ("  rsrc = 0x%x,", rsrc);
14768                                 printf ("  rdst = 0x%x,", rdst);
14769                                 printf ("  s = 0x%x\n", s);
14770                               }
14771                             SYNTAX("dmov%s      %1, %0");
14772 #line 1167 "rx-decode.opc"
14773                             ID(dmov); DDRH(rdst); SR(rsrc); DL(s); F_____;
14774
14775                           }
14776                         break;
14777                       case 0x04:
14778                         op_semantics_132:
14779                           {
14780                             /** 1111 1101 0111 0111 1000 rdst rsrc 0100 mvtdc   %1, %0 */
14781 #line 1232 "rx-decode.opc"
14782                             int rdst AU = op[2] & 0x0f;
14783 #line 1232 "rx-decode.opc"
14784                             int rsrc AU = (op[3] >> 4) & 0x0f;
14785                             if (trace)
14786                               {
14787                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14788                                        "/** 1111 1101 0111 0111 1000 rdst rsrc 0100     mvtdc   %1, %0 */",
14789                                        op[0], op[1], op[2], op[3]);
14790                                 printf ("  rdst = 0x%x,", rdst);
14791                                 printf ("  rsrc = 0x%x\n", rsrc);
14792                               }
14793                             SYNTAX("mvtdc       %1, %0");
14794 #line 1232 "rx-decode.opc"
14795                             ID(mvtdc); DCR(rdst); SR(rsrc); F_____;
14796
14797                           }
14798                         break;
14799                       case 0x09:
14800                         op_semantics_133:
14801                           {
14802                             /** 1111 1101 0111 0111 1000 rsrc rdst 1001 itod    %1, %0 */
14803 #line 1274 "rx-decode.opc"
14804                             int rsrc AU = op[2] & 0x0f;
14805 #line 1274 "rx-decode.opc"
14806                             int rdst AU = (op[3] >> 4) & 0x0f;
14807                             if (trace)
14808                               {
14809                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14810                                        "/** 1111 1101 0111 0111 1000 rsrc rdst 1001     itod    %1, %0 */",
14811                                        op[0], op[1], op[2], op[3]);
14812                                 printf ("  rsrc = 0x%x,", rsrc);
14813                                 printf ("  rdst = 0x%x\n", rdst);
14814                               }
14815                             SYNTAX("itod        %1, %0");
14816 #line 1274 "rx-decode.opc"
14817                             ID(itod); DDR(rdst); SR(rsrc); F_____;
14818
14819                           }
14820                         break;
14821                       case 0x0a:
14822                         op_semantics_134:
14823                           {
14824                             /** 1111 1101 0111 0111 1000 rsrc rdst 1010 ftod    %1, %0 */
14825 #line 1271 "rx-decode.opc"
14826                             int rsrc AU = op[2] & 0x0f;
14827 #line 1271 "rx-decode.opc"
14828                             int rdst AU = (op[3] >> 4) & 0x0f;
14829                             if (trace)
14830                               {
14831                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14832                                        "/** 1111 1101 0111 0111 1000 rsrc rdst 1010     ftod    %1, %0 */",
14833                                        op[0], op[1], op[2], op[3]);
14834                                 printf ("  rsrc = 0x%x,", rsrc);
14835                                 printf ("  rdst = 0x%x\n", rdst);
14836                               }
14837                             SYNTAX("ftod        %1, %0");
14838 #line 1271 "rx-decode.opc"
14839                             ID(ftod); DDR(rdst); SR(rsrc); F_____;
14840
14841                           }
14842                         break;
14843                       case 0x0d:
14844                         op_semantics_135:
14845                           {
14846                             /** 1111 1101 0111 0111 1000 rsrc rdst 1101 utod    %1, %0 */
14847 #line 1277 "rx-decode.opc"
14848                             int rsrc AU = op[2] & 0x0f;
14849 #line 1277 "rx-decode.opc"
14850                             int rdst AU = (op[3] >> 4) & 0x0f;
14851                             if (trace)
14852                               {
14853                                 printf ("\033[33m%s\033[0m  %02x %02x %02x %02x\n",
14854                                        "/** 1111 1101 0111 0111 1000 rsrc rdst 1101     utod    %1, %0 */",
14855                                        op[0], op[1], op[2], op[3]);
14856                                 printf ("  rsrc = 0x%x,", rsrc);
14857                                 printf ("  rdst = 0x%x\n", rdst);
14858                               }
14859                             SYNTAX("utod        %1, %0");
14860 #line 1277 "rx-decode.opc"
14861                             ID(dsqrt); DDR(rdst); SR(rsrc); F_____;
14862
14863                           }
14864                         break;
14865                       default: UNSUPPORTED(); break;
14866                     }
14867                   break;
14868                 case 0x81:
14869                     GETBYTE ();
14870                     switch (op[3] & 0x0f)
14871                     {
14872                       case 0x00:
14873                         goto op_semantics_130;
14874                         break;
14875                       case 0x02:
14876                       case 0x03:
14877                         goto op_semantics_131;
14878                         break;
14879                       case 0x04:
14880                         goto op_semantics_132;
14881                         break;
14882                       case 0x09:
14883                         goto op_semantics_133;
14884                         break;
14885                       case 0x0a:
14886                         goto op_semantics_134;
14887                         break;
14888                       case 0x0d:
14889                         goto op_semantics_135;
14890                         break;
14891                       default: UNSUPPORTED(); break;
14892                     }
14893                   break;
14894                 case 0x82:
14895                     GETBYTE ();
14896                     switch (op[3] & 0x0f)
14897                     {
14898                       case 0x00:
14899                         goto op_semantics_130;
14900                         break;
14901                       case 0x02:
14902                       case 0x03:
14903                         goto op_semantics_131;
14904                         break;
14905                       case 0x04:
14906                         goto op_semantics_132;
14907                         break;
14908                       case 0x09:
14909                         goto op_semantics_133;
14910                         break;
14911                       case 0x0a:
14912                         goto op_semantics_134;
14913                         break;
14914                       case 0x0d:
14915                         goto op_semantics_135;
14916                         break;
14917                       default: UNSUPPORTED(); break;
14918                     }
14919                   break;
14920                 case 0x83:
14921                     GETBYTE ();
14922                     switch (op[3] & 0x0f)
14923                     {
14924                       case 0x00:
14925                         goto op_semantics_130;
14926                         break;
14927                       case 0x02:
14928                       case 0x03:
14929                         goto op_semantics_131;
14930                         break;
14931                       case 0x04:
14932                         goto op_semantics_132;
14933                         break;
14934                       case 0x09:
14935                         goto op_semantics_133;
14936                         break;
14937                       case 0x0a:
14938                         goto op_semantics_134;
14939                         break;
14940                       case 0x0d:
14941                         goto op_semantics_135;
14942                         break;
14943                       default: UNSUPPORTED(); break;
14944                     }
14945                   break;
14946                 case 0x84:
14947                     GETBYTE ();
14948                     switch (op[3] & 0x0f)
14949                     {
14950                       case 0x00:
14951                         goto op_semantics_130;
14952                         break;
14953                       case 0x02:
14954                       case 0x03:
14955                         goto op_semantics_131;
14956                         break;
14957                       case 0x04:
14958                         goto op_semantics_132;
14959                         break;
14960                       case 0x09:
14961                         goto op_semantics_133;
14962                         break;
14963                       case 0x0a:
14964                         goto op_semantics_134;
14965                         break;
14966                       case 0x0d:
14967                         goto op_semantics_135;
14968                         break;
14969                       default: UNSUPPORTED(); break;
14970                     }
14971                   break;
14972                 case 0x85:
14973                     GETBYTE ();
14974                     switch (op[3] & 0x0f)
14975                     {
14976                       case 0x00:
14977                         goto op_semantics_130;
14978                         break;
14979                       case 0x02:
14980                       case 0x03:
14981                         goto op_semantics_131;
14982                         break;
14983                       case 0x04:
14984                         goto op_semantics_132;
14985                         break;
14986                       case 0x09:
14987                         goto op_semantics_133;
14988                         break;
14989                       case 0x0a:
14990                         goto op_semantics_134;
14991                         break;
14992                       case 0x0d:
14993                         goto op_semantics_135;
14994                         break;
14995                       default: UNSUPPORTED(); break;
14996                     }
14997                   break;
14998                 case 0x86:
14999                     GETBYTE ();
15000                     switch (op[3] & 0x0f)
15001                     {
15002                       case 0x00:
15003                         goto op_semantics_130;
15004                         break;
15005                       case 0x02:
15006                       case 0x03:
15007                         goto op_semantics_131;
15008                         break;
15009                       case 0x04:
15010                         goto op_semantics_132;
15011                         break;
15012                       case 0x09:
15013                         goto op_semantics_133;
15014                         break;
15015                       case 0x0a:
15016                         goto op_semantics_134;
15017                         break;
15018                       case 0x0d:
15019                         goto op_semantics_135;
15020                         break;
15021                       default: UNSUPPORTED(); break;
15022                     }
15023                   break;
15024                 case 0x87:
15025                     GETBYTE ();
15026                     switch (op[3] & 0x0f)
15027                     {
15028                       case 0x00:
15029                         goto op_semantics_130;
15030                         break;
15031                       case 0x02:
15032                       case 0x03:
15033                         goto op_semantics_131;
15034                         break;
15035                       case 0x04:
15036                         goto op_semantics_132;
15037                         break;
15038                       case 0x09:
15039                         goto op_semantics_133;
15040                         break;
15041                       case 0x0a:
15042                         goto op_semantics_134;
15043                         break;
15044                       case 0x0d:
15045                         goto op_semantics_135;
15046                         break;
15047                       default: UNSUPPORTED(); break;
15048                     }
15049                   break;
15050                 case 0x88:
15051                     GETBYTE ();
15052                     switch (op[3] & 0x0f)
15053                     {
15054                       case 0x00:
15055                         goto op_semantics_130;
15056                         break;
15057                       case 0x02:
15058                       case 0x03:
15059                         goto op_semantics_131;
15060                         break;
15061                       case 0x04:
15062                         goto op_semantics_132;
15063                         break;
15064                       case 0x09:
15065                         goto op_semantics_133;
15066                         break;
15067                       case 0x0a:
15068                         goto op_semantics_134;
15069                         break;
15070                       case 0x0d:
15071                         goto op_semantics_135;
15072                         break;
15073                       default: UNSUPPORTED(); break;
15074                     }
15075                   break;
15076                 case 0x89:
15077                     GETBYTE ();
15078                     switch (op[3] & 0x0f)
15079                     {
15080                       case 0x00:
15081                         goto op_semantics_130;
15082                         break;
15083                       case 0x02:
15084                       case 0x03:
15085                         goto op_semantics_131;
15086                         break;
15087                       case 0x04:
15088                         goto op_semantics_132;
15089                         break;
15090                       case 0x09:
15091                         goto op_semantics_133;
15092                         break;
15093                       case 0x0a:
15094                         goto op_semantics_134;
15095                         break;
15096                       case 0x0d:
15097                         goto op_semantics_135;
15098                         break;
15099                       default: UNSUPPORTED(); break;
15100                     }
15101                   break;
15102                 case 0x8a:
15103                     GETBYTE ();
15104                     switch (op[3] & 0x0f)
15105                     {
15106                       case 0x00:
15107                         goto op_semantics_130;
15108                         break;
15109                       case 0x02:
15110                       case 0x03:
15111                         goto op_semantics_131;
15112                         break;
15113                       case 0x04:
15114                         goto op_semantics_132;
15115                         break;
15116                       case 0x09:
15117                         goto op_semantics_133;
15118                         break;
15119                       case 0x0a:
15120                         goto op_semantics_134;
15121                         break;
15122                       case 0x0d:
15123                         goto op_semantics_135;
15124                         break;
15125                       default: UNSUPPORTED(); break;
15126                     }
15127                   break;
15128                 case 0x8b:
15129                     GETBYTE ();
15130                     switch (op[3] & 0x0f)
15131                     {
15132                       case 0x00:
15133                         goto op_semantics_130;
15134                         break;
15135                       case 0x02:
15136                       case 0x03:
15137                         goto op_semantics_131;
15138                         break;
15139                       case 0x04:
15140                         goto op_semantics_132;
15141                         break;
15142                       case 0x09:
15143                         goto op_semantics_133;
15144                         break;
15145                       case 0x0a:
15146                         goto op_semantics_134;
15147                         break;
15148                       case 0x0d:
15149                         goto op_semantics_135;
15150                         break;
15151                       default: UNSUPPORTED(); break;
15152                     }
15153                   break;
15154                 case 0x8c:
15155                     GETBYTE ();
15156                     switch (op[3] & 0x0f)
15157                     {
15158                       case 0x00:
15159                         goto op_semantics_130;
15160                         break;
15161                       case 0x02:
15162                       case 0x03:
15163                         goto op_semantics_131;
15164                         break;
15165                       case 0x04:
15166                         goto op_semantics_132;
15167                         break;
15168                       case 0x09:
15169                         goto op_semantics_133;
15170                         break;
15171                       case 0x0a:
15172                         goto op_semantics_134;
15173                         break;
15174                       case 0x0d:
15175                         goto op_semantics_135;
15176                         break;
15177                       default: UNSUPPORTED(); break;
15178                     }
15179                   break;
15180                 case 0x8d:
15181                     GETBYTE ();
15182                     switch (op[3] & 0x0f)
15183                     {
15184                       case 0x00:
15185                         goto op_semantics_130;
15186                         break;
15187                       case 0x02:
15188                       case 0x03:
15189                         goto op_semantics_131;
15190                         break;
15191                       case 0x04:
15192                         goto op_semantics_132;
15193                         break;
15194                       case 0x09:
15195                         goto op_semantics_133;
15196                         break;
15197                       case 0x0a:
15198                         goto op_semantics_134;
15199                         break;
15200                       case 0x0d:
15201                         goto op_semantics_135;
15202                         break;
15203                       default: UNSUPPORTED(); break;
15204                     }
15205                   break;
15206                 case 0x8e:
15207                     GETBYTE ();
15208                     switch (op[3] & 0x0f)
15209                     {
15210                       case 0x00:
15211                         goto op_semantics_130;
15212                         break;
15213                       case 0x02:
15214                       case 0x03:
15215                         goto op_semantics_131;
15216                         break;
15217                       case 0x04:
15218                         goto op_semantics_132;
15219                         break;
15220                       case 0x09:
15221                         goto op_semantics_133;
15222                         break;
15223                       case 0x0a:
15224                         goto op_semantics_134;
15225                         break;
15226                       case 0x0d:
15227                         goto op_semantics_135;
15228                         break;
15229                       default: UNSUPPORTED(); break;
15230                     }
15231                   break;
15232                 case 0x8f:
15233                     GETBYTE ();
15234                     switch (op[3] & 0x0f)
15235                     {
15236                       case 0x00:
15237                         goto op_semantics_130;
15238                         break;
15239                       case 0x02:
15240                       case 0x03:
15241                         goto op_semantics_131;
15242                         break;
15243                       case 0x04:
15244                         goto op_semantics_132;
15245                         break;
15246                       case 0x09:
15247                         goto op_semantics_133;
15248                         break;
15249                       case 0x0a:
15250                         goto op_semantics_134;
15251                         break;
15252                       case 0x0d:
15253                         goto op_semantics_135;
15254                         break;
15255                       default: UNSUPPORTED(); break;
15256                     }
15257                   break;
15258                 default: UNSUPPORTED(); break;
15259               }
15260             break;
15261           case 0x78:
15262               GETBYTE ();
15263               switch (op[2] & 0xf0)
15264               {
15265                 case 0x20:
15266                   goto op_semantics_113;
15267                   break;
15268                 case 0x40:
15269                   goto op_semantics_114;
15270                   break;
15271                 case 0x50:
15272                   goto op_semantics_115;
15273                   break;
15274                 case 0x60:
15275                   goto op_semantics_116;
15276                   break;
15277                 case 0x70:
15278                   goto op_semantics_117;
15279                   break;
15280                 case 0x80:
15281                   goto op_semantics_118;
15282                   break;
15283                 case 0x90:
15284                   goto op_semantics_119;
15285                   break;
15286                 case 0xc0:
15287                   goto op_semantics_120;
15288                   break;
15289                 case 0xd0:
15290                   goto op_semantics_121;
15291                   break;
15292                 case 0xe0:
15293                   goto op_semantics_122;
15294                   break;
15295                 case 0xf0:
15296                   goto op_semantics_123;
15297                   break;
15298                 default: UNSUPPORTED(); break;
15299               }
15300             break;
15301           case 0x7b:
15302               GETBYTE ();
15303               switch (op[2] & 0xe0)
15304               {
15305                 case 0x00:
15306                   goto op_semantics_124;
15307                   break;
15308                 default: UNSUPPORTED(); break;
15309               }
15310             break;
15311           case 0x7c:
15312               GETBYTE ();
15313               switch (op[2] & 0xf0)
15314               {
15315                 case 0x20:
15316                   goto op_semantics_113;
15317                   break;
15318                 case 0x40:
15319                   goto op_semantics_114;
15320                   break;
15321                 case 0x50:
15322                   goto op_semantics_115;
15323                   break;
15324                 case 0x60:
15325                   goto op_semantics_116;
15326                   break;
15327                 case 0x70:
15328                   goto op_semantics_117;
15329                   break;
15330                 case 0x80:
15331                   goto op_semantics_118;
15332                   break;
15333                 case 0x90:
15334                   goto op_semantics_119;
15335                   break;
15336                 case 0xc0:
15337                   goto op_semantics_120;
15338                   break;
15339                 case 0xd0:
15340                   goto op_semantics_121;
15341                   break;
15342                 case 0xe0:
15343                   goto op_semantics_122;
15344                   break;
15345                 case 0xf0:
15346                   goto op_semantics_123;
15347                   break;
15348                 default: UNSUPPORTED(); break;
15349               }
15350             break;
15351           case 0x7f:
15352               GETBYTE ();
15353               switch (op[2] & 0xe0)
15354               {
15355                 case 0x00:
15356                   goto op_semantics_124;
15357                   break;
15358                 default: UNSUPPORTED(); break;
15359               }
15360             break;
15361           case 0x80:
15362               GETBYTE ();
15363               switch (op[2] & 0x00)
15364               {
15365                 case 0x00:
15366                   op_semantics_136:
15367                     {
15368                       /** 1111 1101 100immmm rsrc rdst  shlr    #%2, %1, %0 */
15369 #line 757 "rx-decode.opc"
15370                       int immmm AU = op[1] & 0x1f;
15371 #line 757 "rx-decode.opc"
15372                       int rsrc AU = (op[2] >> 4) & 0x0f;
15373 #line 757 "rx-decode.opc"
15374                       int rdst AU = op[2] & 0x0f;
15375                       if (trace)
15376                         {
15377                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15378                                  "/** 1111 1101 100immmm rsrc rdst      shlr    #%2, %1, %0 */",
15379                                  op[0], op[1], op[2]);
15380                           printf ("  immmm = 0x%x,", immmm);
15381                           printf ("  rsrc = 0x%x,", rsrc);
15382                           printf ("  rdst = 0x%x\n", rdst);
15383                         }
15384                       SYNTAX("shlr      #%2, %1, %0");
15385 #line 757 "rx-decode.opc"
15386                       ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
15387
15388                     /*----------------------------------------------------------------------*/
15389                     /* ROTATE                                                           */
15390
15391                     }
15392                   break;
15393               }
15394             break;
15395           case 0x81:
15396               GETBYTE ();
15397               switch (op[2] & 0x00)
15398               {
15399                 case 0x00:
15400                   goto op_semantics_136;
15401                   break;
15402               }
15403             break;
15404           case 0x82:
15405               GETBYTE ();
15406               switch (op[2] & 0x00)
15407               {
15408                 case 0x00:
15409                   goto op_semantics_136;
15410                   break;
15411               }
15412             break;
15413           case 0x83:
15414               GETBYTE ();
15415               switch (op[2] & 0x00)
15416               {
15417                 case 0x00:
15418                   goto op_semantics_136;
15419                   break;
15420               }
15421             break;
15422           case 0x84:
15423               GETBYTE ();
15424               switch (op[2] & 0x00)
15425               {
15426                 case 0x00:
15427                   goto op_semantics_136;
15428                   break;
15429               }
15430             break;
15431           case 0x85:
15432               GETBYTE ();
15433               switch (op[2] & 0x00)
15434               {
15435                 case 0x00:
15436                   goto op_semantics_136;
15437                   break;
15438               }
15439             break;
15440           case 0x86:
15441               GETBYTE ();
15442               switch (op[2] & 0x00)
15443               {
15444                 case 0x00:
15445                   goto op_semantics_136;
15446                   break;
15447               }
15448             break;
15449           case 0x87:
15450               GETBYTE ();
15451               switch (op[2] & 0x00)
15452               {
15453                 case 0x00:
15454                   goto op_semantics_136;
15455                   break;
15456               }
15457             break;
15458           case 0x88:
15459               GETBYTE ();
15460               switch (op[2] & 0x00)
15461               {
15462                 case 0x00:
15463                   goto op_semantics_136;
15464                   break;
15465               }
15466             break;
15467           case 0x89:
15468               GETBYTE ();
15469               switch (op[2] & 0x00)
15470               {
15471                 case 0x00:
15472                   goto op_semantics_136;
15473                   break;
15474               }
15475             break;
15476           case 0x8a:
15477               GETBYTE ();
15478               switch (op[2] & 0x00)
15479               {
15480                 case 0x00:
15481                   goto op_semantics_136;
15482                   break;
15483               }
15484             break;
15485           case 0x8b:
15486               GETBYTE ();
15487               switch (op[2] & 0x00)
15488               {
15489                 case 0x00:
15490                   goto op_semantics_136;
15491                   break;
15492               }
15493             break;
15494           case 0x8c:
15495               GETBYTE ();
15496               switch (op[2] & 0x00)
15497               {
15498                 case 0x00:
15499                   goto op_semantics_136;
15500                   break;
15501               }
15502             break;
15503           case 0x8d:
15504               GETBYTE ();
15505               switch (op[2] & 0x00)
15506               {
15507                 case 0x00:
15508                   goto op_semantics_136;
15509                   break;
15510               }
15511             break;
15512           case 0x8e:
15513               GETBYTE ();
15514               switch (op[2] & 0x00)
15515               {
15516                 case 0x00:
15517                   goto op_semantics_136;
15518                   break;
15519               }
15520             break;
15521           case 0x8f:
15522               GETBYTE ();
15523               switch (op[2] & 0x00)
15524               {
15525                 case 0x00:
15526                   goto op_semantics_136;
15527                   break;
15528               }
15529             break;
15530           case 0x90:
15531               GETBYTE ();
15532               switch (op[2] & 0x00)
15533               {
15534                 case 0x00:
15535                   goto op_semantics_136;
15536                   break;
15537               }
15538             break;
15539           case 0x91:
15540               GETBYTE ();
15541               switch (op[2] & 0x00)
15542               {
15543                 case 0x00:
15544                   goto op_semantics_136;
15545                   break;
15546               }
15547             break;
15548           case 0x92:
15549               GETBYTE ();
15550               switch (op[2] & 0x00)
15551               {
15552                 case 0x00:
15553                   goto op_semantics_136;
15554                   break;
15555               }
15556             break;
15557           case 0x93:
15558               GETBYTE ();
15559               switch (op[2] & 0x00)
15560               {
15561                 case 0x00:
15562                   goto op_semantics_136;
15563                   break;
15564               }
15565             break;
15566           case 0x94:
15567               GETBYTE ();
15568               switch (op[2] & 0x00)
15569               {
15570                 case 0x00:
15571                   goto op_semantics_136;
15572                   break;
15573               }
15574             break;
15575           case 0x95:
15576               GETBYTE ();
15577               switch (op[2] & 0x00)
15578               {
15579                 case 0x00:
15580                   goto op_semantics_136;
15581                   break;
15582               }
15583             break;
15584           case 0x96:
15585               GETBYTE ();
15586               switch (op[2] & 0x00)
15587               {
15588                 case 0x00:
15589                   goto op_semantics_136;
15590                   break;
15591               }
15592             break;
15593           case 0x97:
15594               GETBYTE ();
15595               switch (op[2] & 0x00)
15596               {
15597                 case 0x00:
15598                   goto op_semantics_136;
15599                   break;
15600               }
15601             break;
15602           case 0x98:
15603               GETBYTE ();
15604               switch (op[2] & 0x00)
15605               {
15606                 case 0x00:
15607                   goto op_semantics_136;
15608                   break;
15609               }
15610             break;
15611           case 0x99:
15612               GETBYTE ();
15613               switch (op[2] & 0x00)
15614               {
15615                 case 0x00:
15616                   goto op_semantics_136;
15617                   break;
15618               }
15619             break;
15620           case 0x9a:
15621               GETBYTE ();
15622               switch (op[2] & 0x00)
15623               {
15624                 case 0x00:
15625                   goto op_semantics_136;
15626                   break;
15627               }
15628             break;
15629           case 0x9b:
15630               GETBYTE ();
15631               switch (op[2] & 0x00)
15632               {
15633                 case 0x00:
15634                   goto op_semantics_136;
15635                   break;
15636               }
15637             break;
15638           case 0x9c:
15639               GETBYTE ();
15640               switch (op[2] & 0x00)
15641               {
15642                 case 0x00:
15643                   goto op_semantics_136;
15644                   break;
15645               }
15646             break;
15647           case 0x9d:
15648               GETBYTE ();
15649               switch (op[2] & 0x00)
15650               {
15651                 case 0x00:
15652                   goto op_semantics_136;
15653                   break;
15654               }
15655             break;
15656           case 0x9e:
15657               GETBYTE ();
15658               switch (op[2] & 0x00)
15659               {
15660                 case 0x00:
15661                   goto op_semantics_136;
15662                   break;
15663               }
15664             break;
15665           case 0x9f:
15666               GETBYTE ();
15667               switch (op[2] & 0x00)
15668               {
15669                 case 0x00:
15670                   goto op_semantics_136;
15671                   break;
15672               }
15673             break;
15674           case 0xa0:
15675               GETBYTE ();
15676               switch (op[2] & 0x00)
15677               {
15678                 case 0x00:
15679                   op_semantics_137:
15680                     {
15681                       /** 1111 1101 101immmm rsrc rdst  shar    #%2, %1, %0 */
15682 #line 747 "rx-decode.opc"
15683                       int immmm AU = op[1] & 0x1f;
15684 #line 747 "rx-decode.opc"
15685                       int rsrc AU = (op[2] >> 4) & 0x0f;
15686 #line 747 "rx-decode.opc"
15687                       int rdst AU = op[2] & 0x0f;
15688                       if (trace)
15689                         {
15690                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
15691                                  "/** 1111 1101 101immmm rsrc rdst      shar    #%2, %1, %0 */",
15692                                  op[0], op[1], op[2]);
15693                           printf ("  immmm = 0x%x,", immmm);
15694                           printf ("  rsrc = 0x%x,", rsrc);
15695                           printf ("  rdst = 0x%x\n", rdst);
15696                         }
15697                       SYNTAX("shar      #%2, %1, %0");
15698 #line 747 "rx-decode.opc"
15699                       ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
15700
15701
15702                     }
15703                   break;
15704               }
15705             break;
15706           case 0xa1:
15707               GETBYTE ();
15708               switch (op[2] & 0x00)
15709               {
15710                 case 0x00:
15711                   goto op_semantics_137;
15712                   break;
15713               }
15714             break;
15715           case 0xa2:
15716               GETBYTE ();
15717               switch (op[2] & 0x00)
15718               {
15719                 case 0x00:
15720                   goto op_semantics_137;
15721                   break;
15722               }
15723             break;
15724           case 0xa3:
15725               GETBYTE ();
15726               switch (op[2] & 0x00)
15727               {
15728                 case 0x00:
15729                   goto op_semantics_137;
15730                   break;
15731               }
15732             break;
15733           case 0xa4:
15734               GETBYTE ();
15735               switch (op[2] & 0x00)
15736               {
15737                 case 0x00:
15738                   goto op_semantics_137;
15739                   break;
15740               }
15741             break;
15742           case 0xa5:
15743               GETBYTE ();
15744               switch (op[2] & 0x00)
15745               {
15746                 case 0x00:
15747                   goto op_semantics_137;
15748                   break;
15749               }
15750             break;
15751           case 0xa6:
15752               GETBYTE ();
15753               switch (op[2] & 0x00)
15754               {
15755                 case 0x00:
15756                   goto op_semantics_137;
15757                   break;
15758               }
15759             break;
15760           case 0xa7:
15761               GETBYTE ();
15762               switch (op[2] & 0x00)
15763               {
15764                 case 0x00:
15765                   goto op_semantics_137;
15766                   break;
15767               }
15768             break;
15769           case 0xa8:
15770               GETBYTE ();
15771               switch (op[2] & 0x00)
15772               {
15773                 case 0x00:
15774                   goto op_semantics_137;
15775                   break;
15776               }
15777             break;
15778           case 0xa9:
15779               GETBYTE ();
15780               switch (op[2] & 0x00)
15781               {
15782                 case 0x00:
15783                   goto op_semantics_137;
15784                   break;
15785               }
15786             break;
15787           case 0xaa:
15788               GETBYTE ();
15789               switch (op[2] & 0x00)
15790               {
15791                 case 0x00:
15792                   goto op_semantics_137;
15793                   break;
15794               }
15795             break;
15796           case 0xab:
15797               GETBYTE ();
15798               switch (op[2] & 0x00)
15799               {
15800                 case 0x00:
15801                   goto op_semantics_137;
15802                   break;
15803               }
15804             break;
15805           case 0xac:
15806               GETBYTE ();
15807               switch (op[2] & 0x00)
15808               {
15809                 case 0x00:
15810                   goto op_semantics_137;
15811                   break;
15812               }
15813             break;
15814           case 0xad:
15815               GETBYTE ();
15816               switch (op[2] & 0x00)
15817               {
15818                 case 0x00:
15819                   goto op_semantics_137;
15820                   break;
15821               }
15822             break;
15823           case 0xae:
15824               GETBYTE ();
15825               switch (op[2] & 0x00)
15826               {
15827                 case 0x00:
15828                   goto op_semantics_137;
15829                   break;
15830               }
15831             break;
15832           case 0xaf:
15833               GETBYTE ();
15834               switch (op[2] & 0x00)
15835               {
15836                 case 0x00:
15837                   goto op_semantics_137;
15838                   break;
15839               }
15840             break;
15841           case 0xb0:
15842               GETBYTE ();
15843               switch (op[2] & 0x00)
15844               {
15845                 case 0x00:
15846                   goto op_semantics_137;
15847                   break;
15848               }
15849             break;
15850           case 0xb1:
15851               GETBYTE ();
15852               switch (op[2] & 0x00)
15853               {
15854                 case 0x00:
15855                   goto op_semantics_137;
15856                   break;
15857               }
15858             break;
15859           case 0xb2:
15860               GETBYTE ();
15861               switch (op[2] & 0x00)
15862               {
15863                 case 0x00:
15864                   goto op_semantics_137;
15865                   break;
15866               }
15867             break;
15868           case 0xb3:
15869               GETBYTE ();
15870               switch (op[2] & 0x00)
15871               {
15872                 case 0x00:
15873                   goto op_semantics_137;
15874                   break;
15875               }
15876             break;
15877           case 0xb4:
15878               GETBYTE ();
15879               switch (op[2] & 0x00)
15880               {
15881                 case 0x00:
15882                   goto op_semantics_137;
15883                   break;
15884               }
15885             break;
15886           case 0xb5:
15887               GETBYTE ();
15888               switch (op[2] & 0x00)
15889               {
15890                 case 0x00:
15891                   goto op_semantics_137;
15892                   break;
15893               }
15894             break;
15895           case 0xb6:
15896               GETBYTE ();
15897               switch (op[2] & 0x00)
15898               {
15899                 case 0x00:
15900                   goto op_semantics_137;
15901                   break;
15902               }
15903             break;
15904           case 0xb7:
15905               GETBYTE ();
15906               switch (op[2] & 0x00)
15907               {
15908                 case 0x00:
15909                   goto op_semantics_137;
15910                   break;
15911               }
15912             break;
15913           case 0xb8:
15914               GETBYTE ();
15915               switch (op[2] & 0x00)
15916               {
15917                 case 0x00:
15918                   goto op_semantics_137;
15919                   break;
15920               }
15921             break;
15922           case 0xb9:
15923               GETBYTE ();
15924               switch (op[2] & 0x00)
15925               {
15926                 case 0x00:
15927                   goto op_semantics_137;
15928                   break;
15929               }
15930             break;
15931           case 0xba:
15932               GETBYTE ();
15933               switch (op[2] & 0x00)
15934               {
15935                 case 0x00:
15936                   goto op_semantics_137;
15937                   break;
15938               }
15939             break;
15940           case 0xbb:
15941               GETBYTE ();
15942               switch (op[2] & 0x00)
15943               {
15944                 case 0x00:
15945                   goto op_semantics_137;
15946                   break;
15947               }
15948             break;
15949           case 0xbc:
15950               GETBYTE ();
15951               switch (op[2] & 0x00)
15952               {
15953                 case 0x00:
15954                   goto op_semantics_137;
15955                   break;
15956               }
15957             break;
15958           case 0xbd:
15959               GETBYTE ();
15960               switch (op[2] & 0x00)
15961               {
15962                 case 0x00:
15963                   goto op_semantics_137;
15964                   break;
15965               }
15966             break;
15967           case 0xbe:
15968               GETBYTE ();
15969               switch (op[2] & 0x00)
15970               {
15971                 case 0x00:
15972                   goto op_semantics_137;
15973                   break;
15974               }
15975             break;
15976           case 0xbf:
15977               GETBYTE ();
15978               switch (op[2] & 0x00)
15979               {
15980                 case 0x00:
15981                   goto op_semantics_137;
15982                   break;
15983               }
15984             break;
15985           case 0xc0:
15986               GETBYTE ();
15987               switch (op[2] & 0x00)
15988               {
15989                 case 0x00:
15990                   op_semantics_138:
15991                     {
15992                       /** 1111 1101 110immmm rsrc rdst  shll    #%2, %1, %0 */
15993 #line 737 "rx-decode.opc"
15994                       int immmm AU = op[1] & 0x1f;
15995 #line 737 "rx-decode.opc"
15996                       int rsrc AU = (op[2] >> 4) & 0x0f;
15997 #line 737 "rx-decode.opc"
15998                       int rdst AU = op[2] & 0x0f;
15999                       if (trace)
16000                         {
16001                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16002                                  "/** 1111 1101 110immmm rsrc rdst      shll    #%2, %1, %0 */",
16003                                  op[0], op[1], op[2]);
16004                           printf ("  immmm = 0x%x,", immmm);
16005                           printf ("  rsrc = 0x%x,", rsrc);
16006                           printf ("  rdst = 0x%x\n", rdst);
16007                         }
16008                       SYNTAX("shll      #%2, %1, %0");
16009 #line 737 "rx-decode.opc"
16010                       ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
16011
16012
16013                     }
16014                   break;
16015               }
16016             break;
16017           case 0xc1:
16018               GETBYTE ();
16019               switch (op[2] & 0x00)
16020               {
16021                 case 0x00:
16022                   goto op_semantics_138;
16023                   break;
16024               }
16025             break;
16026           case 0xc2:
16027               GETBYTE ();
16028               switch (op[2] & 0x00)
16029               {
16030                 case 0x00:
16031                   goto op_semantics_138;
16032                   break;
16033               }
16034             break;
16035           case 0xc3:
16036               GETBYTE ();
16037               switch (op[2] & 0x00)
16038               {
16039                 case 0x00:
16040                   goto op_semantics_138;
16041                   break;
16042               }
16043             break;
16044           case 0xc4:
16045               GETBYTE ();
16046               switch (op[2] & 0x00)
16047               {
16048                 case 0x00:
16049                   goto op_semantics_138;
16050                   break;
16051               }
16052             break;
16053           case 0xc5:
16054               GETBYTE ();
16055               switch (op[2] & 0x00)
16056               {
16057                 case 0x00:
16058                   goto op_semantics_138;
16059                   break;
16060               }
16061             break;
16062           case 0xc6:
16063               GETBYTE ();
16064               switch (op[2] & 0x00)
16065               {
16066                 case 0x00:
16067                   goto op_semantics_138;
16068                   break;
16069               }
16070             break;
16071           case 0xc7:
16072               GETBYTE ();
16073               switch (op[2] & 0x00)
16074               {
16075                 case 0x00:
16076                   goto op_semantics_138;
16077                   break;
16078               }
16079             break;
16080           case 0xc8:
16081               GETBYTE ();
16082               switch (op[2] & 0x00)
16083               {
16084                 case 0x00:
16085                   goto op_semantics_138;
16086                   break;
16087               }
16088             break;
16089           case 0xc9:
16090               GETBYTE ();
16091               switch (op[2] & 0x00)
16092               {
16093                 case 0x00:
16094                   goto op_semantics_138;
16095                   break;
16096               }
16097             break;
16098           case 0xca:
16099               GETBYTE ();
16100               switch (op[2] & 0x00)
16101               {
16102                 case 0x00:
16103                   goto op_semantics_138;
16104                   break;
16105               }
16106             break;
16107           case 0xcb:
16108               GETBYTE ();
16109               switch (op[2] & 0x00)
16110               {
16111                 case 0x00:
16112                   goto op_semantics_138;
16113                   break;
16114               }
16115             break;
16116           case 0xcc:
16117               GETBYTE ();
16118               switch (op[2] & 0x00)
16119               {
16120                 case 0x00:
16121                   goto op_semantics_138;
16122                   break;
16123               }
16124             break;
16125           case 0xcd:
16126               GETBYTE ();
16127               switch (op[2] & 0x00)
16128               {
16129                 case 0x00:
16130                   goto op_semantics_138;
16131                   break;
16132               }
16133             break;
16134           case 0xce:
16135               GETBYTE ();
16136               switch (op[2] & 0x00)
16137               {
16138                 case 0x00:
16139                   goto op_semantics_138;
16140                   break;
16141               }
16142             break;
16143           case 0xcf:
16144               GETBYTE ();
16145               switch (op[2] & 0x00)
16146               {
16147                 case 0x00:
16148                   goto op_semantics_138;
16149                   break;
16150               }
16151             break;
16152           case 0xd0:
16153               GETBYTE ();
16154               switch (op[2] & 0x00)
16155               {
16156                 case 0x00:
16157                   goto op_semantics_138;
16158                   break;
16159               }
16160             break;
16161           case 0xd1:
16162               GETBYTE ();
16163               switch (op[2] & 0x00)
16164               {
16165                 case 0x00:
16166                   goto op_semantics_138;
16167                   break;
16168               }
16169             break;
16170           case 0xd2:
16171               GETBYTE ();
16172               switch (op[2] & 0x00)
16173               {
16174                 case 0x00:
16175                   goto op_semantics_138;
16176                   break;
16177               }
16178             break;
16179           case 0xd3:
16180               GETBYTE ();
16181               switch (op[2] & 0x00)
16182               {
16183                 case 0x00:
16184                   goto op_semantics_138;
16185                   break;
16186               }
16187             break;
16188           case 0xd4:
16189               GETBYTE ();
16190               switch (op[2] & 0x00)
16191               {
16192                 case 0x00:
16193                   goto op_semantics_138;
16194                   break;
16195               }
16196             break;
16197           case 0xd5:
16198               GETBYTE ();
16199               switch (op[2] & 0x00)
16200               {
16201                 case 0x00:
16202                   goto op_semantics_138;
16203                   break;
16204               }
16205             break;
16206           case 0xd6:
16207               GETBYTE ();
16208               switch (op[2] & 0x00)
16209               {
16210                 case 0x00:
16211                   goto op_semantics_138;
16212                   break;
16213               }
16214             break;
16215           case 0xd7:
16216               GETBYTE ();
16217               switch (op[2] & 0x00)
16218               {
16219                 case 0x00:
16220                   goto op_semantics_138;
16221                   break;
16222               }
16223             break;
16224           case 0xd8:
16225               GETBYTE ();
16226               switch (op[2] & 0x00)
16227               {
16228                 case 0x00:
16229                   goto op_semantics_138;
16230                   break;
16231               }
16232             break;
16233           case 0xd9:
16234               GETBYTE ();
16235               switch (op[2] & 0x00)
16236               {
16237                 case 0x00:
16238                   goto op_semantics_138;
16239                   break;
16240               }
16241             break;
16242           case 0xda:
16243               GETBYTE ();
16244               switch (op[2] & 0x00)
16245               {
16246                 case 0x00:
16247                   goto op_semantics_138;
16248                   break;
16249               }
16250             break;
16251           case 0xdb:
16252               GETBYTE ();
16253               switch (op[2] & 0x00)
16254               {
16255                 case 0x00:
16256                   goto op_semantics_138;
16257                   break;
16258               }
16259             break;
16260           case 0xdc:
16261               GETBYTE ();
16262               switch (op[2] & 0x00)
16263               {
16264                 case 0x00:
16265                   goto op_semantics_138;
16266                   break;
16267               }
16268             break;
16269           case 0xdd:
16270               GETBYTE ();
16271               switch (op[2] & 0x00)
16272               {
16273                 case 0x00:
16274                   goto op_semantics_138;
16275                   break;
16276               }
16277             break;
16278           case 0xde:
16279               GETBYTE ();
16280               switch (op[2] & 0x00)
16281               {
16282                 case 0x00:
16283                   goto op_semantics_138;
16284                   break;
16285               }
16286             break;
16287           case 0xdf:
16288               GETBYTE ();
16289               switch (op[2] & 0x00)
16290               {
16291                 case 0x00:
16292                   goto op_semantics_138;
16293                   break;
16294               }
16295             break;
16296           case 0xe0:
16297               GETBYTE ();
16298               switch (op[2] & 0xf0)
16299               {
16300                 case 0x00:
16301                 case 0x10:
16302                 case 0x20:
16303                 case 0x30:
16304                 case 0x40:
16305                 case 0x50:
16306                 case 0x60:
16307                 case 0x70:
16308                 case 0x80:
16309                 case 0x90:
16310                 case 0xa0:
16311                 case 0xb0:
16312                 case 0xc0:
16313                 case 0xd0:
16314                 case 0xe0:
16315                   op_semantics_139:
16316                     {
16317                       /** 1111 1101 111 bittt cond rdst bm%2    #%1, %0%S0 */
16318 #line 1011 "rx-decode.opc"
16319                       int bittt AU = op[1] & 0x1f;
16320 #line 1011 "rx-decode.opc"
16321                       int cond AU = (op[2] >> 4) & 0x0f;
16322 #line 1011 "rx-decode.opc"
16323                       int rdst AU = op[2] & 0x0f;
16324                       if (trace)
16325                         {
16326                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16327                                  "/** 1111 1101 111 bittt cond rdst     bm%2    #%1, %0%S0 */",
16328                                  op[0], op[1], op[2]);
16329                           printf ("  bittt = 0x%x,", bittt);
16330                           printf ("  cond = 0x%x,", cond);
16331                           printf ("  rdst = 0x%x\n", rdst);
16332                         }
16333                       SYNTAX("bm%2      #%1, %0%S0");
16334 #line 1011 "rx-decode.opc"
16335                       ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
16336
16337                     /*----------------------------------------------------------------------*/
16338                     /* CONTROL REGISTERS                                                        */
16339
16340                     }
16341                   break;
16342                 case 0xf0:
16343                   op_semantics_140:
16344                     {
16345                       /** 1111 1101 111bittt 1111 rdst  bnot    #%1, %0 */
16346 #line 1004 "rx-decode.opc"
16347                       int bittt AU = op[1] & 0x1f;
16348 #line 1004 "rx-decode.opc"
16349                       int rdst AU = op[2] & 0x0f;
16350                       if (trace)
16351                         {
16352                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
16353                                  "/** 1111 1101 111bittt 1111 rdst      bnot    #%1, %0 */",
16354                                  op[0], op[1], op[2]);
16355                           printf ("  bittt = 0x%x,", bittt);
16356                           printf ("  rdst = 0x%x\n", rdst);
16357                         }
16358                       SYNTAX("bnot      #%1, %0");
16359 #line 1004 "rx-decode.opc"
16360                       ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
16361
16362
16363                     }
16364                   break;
16365               }
16366             break;
16367           case 0xe1:
16368               GETBYTE ();
16369               switch (op[2] & 0xf0)
16370               {
16371                 case 0x00:
16372                 case 0x10:
16373                 case 0x20:
16374                 case 0x30:
16375                 case 0x40:
16376                 case 0x50:
16377                 case 0x60:
16378                 case 0x70:
16379                 case 0x80:
16380                 case 0x90:
16381                 case 0xa0:
16382                 case 0xb0:
16383                 case 0xc0:
16384                 case 0xd0:
16385                 case 0xe0:
16386                   goto op_semantics_139;
16387                   break;
16388                 case 0xf0:
16389                   goto op_semantics_140;
16390                   break;
16391               }
16392             break;
16393           case 0xe2:
16394               GETBYTE ();
16395               switch (op[2] & 0xf0)
16396               {
16397                 case 0x00:
16398                 case 0x10:
16399                 case 0x20:
16400                 case 0x30:
16401                 case 0x40:
16402                 case 0x50:
16403                 case 0x60:
16404                 case 0x70:
16405                 case 0x80:
16406                 case 0x90:
16407                 case 0xa0:
16408                 case 0xb0:
16409                 case 0xc0:
16410                 case 0xd0:
16411                 case 0xe0:
16412                   goto op_semantics_139;
16413                   break;
16414                 case 0xf0:
16415                   goto op_semantics_140;
16416                   break;
16417               }
16418             break;
16419           case 0xe3:
16420               GETBYTE ();
16421               switch (op[2] & 0xf0)
16422               {
16423                 case 0x00:
16424                 case 0x10:
16425                 case 0x20:
16426                 case 0x30:
16427                 case 0x40:
16428                 case 0x50:
16429                 case 0x60:
16430                 case 0x70:
16431                 case 0x80:
16432                 case 0x90:
16433                 case 0xa0:
16434                 case 0xb0:
16435                 case 0xc0:
16436                 case 0xd0:
16437                 case 0xe0:
16438                   goto op_semantics_139;
16439                   break;
16440                 case 0xf0:
16441                   goto op_semantics_140;
16442                   break;
16443               }
16444             break;
16445           case 0xe4:
16446               GETBYTE ();
16447               switch (op[2] & 0xf0)
16448               {
16449                 case 0x00:
16450                 case 0x10:
16451                 case 0x20:
16452                 case 0x30:
16453                 case 0x40:
16454                 case 0x50:
16455                 case 0x60:
16456                 case 0x70:
16457                 case 0x80:
16458                 case 0x90:
16459                 case 0xa0:
16460                 case 0xb0:
16461                 case 0xc0:
16462                 case 0xd0:
16463                 case 0xe0:
16464                   goto op_semantics_139;
16465                   break;
16466                 case 0xf0:
16467                   goto op_semantics_140;
16468                   break;
16469               }
16470             break;
16471           case 0xe5:
16472               GETBYTE ();
16473               switch (op[2] & 0xf0)
16474               {
16475                 case 0x00:
16476                 case 0x10:
16477                 case 0x20:
16478                 case 0x30:
16479                 case 0x40:
16480                 case 0x50:
16481                 case 0x60:
16482                 case 0x70:
16483                 case 0x80:
16484                 case 0x90:
16485                 case 0xa0:
16486                 case 0xb0:
16487                 case 0xc0:
16488                 case 0xd0:
16489                 case 0xe0:
16490                   goto op_semantics_139;
16491                   break;
16492                 case 0xf0:
16493                   goto op_semantics_140;
16494                   break;
16495               }
16496             break;
16497           case 0xe6:
16498               GETBYTE ();
16499               switch (op[2] & 0xf0)
16500               {
16501                 case 0x00:
16502                 case 0x10:
16503                 case 0x20:
16504                 case 0x30:
16505                 case 0x40:
16506                 case 0x50:
16507                 case 0x60:
16508                 case 0x70:
16509                 case 0x80:
16510                 case 0x90:
16511                 case 0xa0:
16512                 case 0xb0:
16513                 case 0xc0:
16514                 case 0xd0:
16515                 case 0xe0:
16516                   goto op_semantics_139;
16517                   break;
16518                 case 0xf0:
16519                   goto op_semantics_140;
16520                   break;
16521               }
16522             break;
16523           case 0xe7:
16524               GETBYTE ();
16525               switch (op[2] & 0xf0)
16526               {
16527                 case 0x00:
16528                 case 0x10:
16529                 case 0x20:
16530                 case 0x30:
16531                 case 0x40:
16532                 case 0x50:
16533                 case 0x60:
16534                 case 0x70:
16535                 case 0x80:
16536                 case 0x90:
16537                 case 0xa0:
16538                 case 0xb0:
16539                 case 0xc0:
16540                 case 0xd0:
16541                 case 0xe0:
16542                   goto op_semantics_139;
16543                   break;
16544                 case 0xf0:
16545                   goto op_semantics_140;
16546                   break;
16547               }
16548             break;
16549           case 0xe8:
16550               GETBYTE ();
16551               switch (op[2] & 0xf0)
16552               {
16553                 case 0x00:
16554                 case 0x10:
16555                 case 0x20:
16556                 case 0x30:
16557                 case 0x40:
16558                 case 0x50:
16559                 case 0x60:
16560                 case 0x70:
16561                 case 0x80:
16562                 case 0x90:
16563                 case 0xa0:
16564                 case 0xb0:
16565                 case 0xc0:
16566                 case 0xd0:
16567                 case 0xe0:
16568                   goto op_semantics_139;
16569                   break;
16570                 case 0xf0:
16571                   goto op_semantics_140;
16572                   break;
16573               }
16574             break;
16575           case 0xe9:
16576               GETBYTE ();
16577               switch (op[2] & 0xf0)
16578               {
16579                 case 0x00:
16580                 case 0x10:
16581                 case 0x20:
16582                 case 0x30:
16583                 case 0x40:
16584                 case 0x50:
16585                 case 0x60:
16586                 case 0x70:
16587                 case 0x80:
16588                 case 0x90:
16589                 case 0xa0:
16590                 case 0xb0:
16591                 case 0xc0:
16592                 case 0xd0:
16593                 case 0xe0:
16594                   goto op_semantics_139;
16595                   break;
16596                 case 0xf0:
16597                   goto op_semantics_140;
16598                   break;
16599               }
16600             break;
16601           case 0xea:
16602               GETBYTE ();
16603               switch (op[2] & 0xf0)
16604               {
16605                 case 0x00:
16606                 case 0x10:
16607                 case 0x20:
16608                 case 0x30:
16609                 case 0x40:
16610                 case 0x50:
16611                 case 0x60:
16612                 case 0x70:
16613                 case 0x80:
16614                 case 0x90:
16615                 case 0xa0:
16616                 case 0xb0:
16617                 case 0xc0:
16618                 case 0xd0:
16619                 case 0xe0:
16620                   goto op_semantics_139;
16621                   break;
16622                 case 0xf0:
16623                   goto op_semantics_140;
16624                   break;
16625               }
16626             break;
16627           case 0xeb:
16628               GETBYTE ();
16629               switch (op[2] & 0xf0)
16630               {
16631                 case 0x00:
16632                 case 0x10:
16633                 case 0x20:
16634                 case 0x30:
16635                 case 0x40:
16636                 case 0x50:
16637                 case 0x60:
16638                 case 0x70:
16639                 case 0x80:
16640                 case 0x90:
16641                 case 0xa0:
16642                 case 0xb0:
16643                 case 0xc0:
16644                 case 0xd0:
16645                 case 0xe0:
16646                   goto op_semantics_139;
16647                   break;
16648                 case 0xf0:
16649                   goto op_semantics_140;
16650                   break;
16651               }
16652             break;
16653           case 0xec:
16654               GETBYTE ();
16655               switch (op[2] & 0xf0)
16656               {
16657                 case 0x00:
16658                 case 0x10:
16659                 case 0x20:
16660                 case 0x30:
16661                 case 0x40:
16662                 case 0x50:
16663                 case 0x60:
16664                 case 0x70:
16665                 case 0x80:
16666                 case 0x90:
16667                 case 0xa0:
16668                 case 0xb0:
16669                 case 0xc0:
16670                 case 0xd0:
16671                 case 0xe0:
16672                   goto op_semantics_139;
16673                   break;
16674                 case 0xf0:
16675                   goto op_semantics_140;
16676                   break;
16677               }
16678             break;
16679           case 0xed:
16680               GETBYTE ();
16681               switch (op[2] & 0xf0)
16682               {
16683                 case 0x00:
16684                 case 0x10:
16685                 case 0x20:
16686                 case 0x30:
16687                 case 0x40:
16688                 case 0x50:
16689                 case 0x60:
16690                 case 0x70:
16691                 case 0x80:
16692                 case 0x90:
16693                 case 0xa0:
16694                 case 0xb0:
16695                 case 0xc0:
16696                 case 0xd0:
16697                 case 0xe0:
16698                   goto op_semantics_139;
16699                   break;
16700                 case 0xf0:
16701                   goto op_semantics_140;
16702                   break;
16703               }
16704             break;
16705           case 0xee:
16706               GETBYTE ();
16707               switch (op[2] & 0xf0)
16708               {
16709                 case 0x00:
16710                 case 0x10:
16711                 case 0x20:
16712                 case 0x30:
16713                 case 0x40:
16714                 case 0x50:
16715                 case 0x60:
16716                 case 0x70:
16717                 case 0x80:
16718                 case 0x90:
16719                 case 0xa0:
16720                 case 0xb0:
16721                 case 0xc0:
16722                 case 0xd0:
16723                 case 0xe0:
16724                   goto op_semantics_139;
16725                   break;
16726                 case 0xf0:
16727                   goto op_semantics_140;
16728                   break;
16729               }
16730             break;
16731           case 0xef:
16732               GETBYTE ();
16733               switch (op[2] & 0xf0)
16734               {
16735                 case 0x00:
16736                 case 0x10:
16737                 case 0x20:
16738                 case 0x30:
16739                 case 0x40:
16740                 case 0x50:
16741                 case 0x60:
16742                 case 0x70:
16743                 case 0x80:
16744                 case 0x90:
16745                 case 0xa0:
16746                 case 0xb0:
16747                 case 0xc0:
16748                 case 0xd0:
16749                 case 0xe0:
16750                   goto op_semantics_139;
16751                   break;
16752                 case 0xf0:
16753                   goto op_semantics_140;
16754                   break;
16755               }
16756             break;
16757           case 0xf0:
16758               GETBYTE ();
16759               switch (op[2] & 0xf0)
16760               {
16761                 case 0x00:
16762                 case 0x10:
16763                 case 0x20:
16764                 case 0x30:
16765                 case 0x40:
16766                 case 0x50:
16767                 case 0x60:
16768                 case 0x70:
16769                 case 0x80:
16770                 case 0x90:
16771                 case 0xa0:
16772                 case 0xb0:
16773                 case 0xc0:
16774                 case 0xd0:
16775                 case 0xe0:
16776                   goto op_semantics_139;
16777                   break;
16778                 case 0xf0:
16779                   goto op_semantics_140;
16780                   break;
16781               }
16782             break;
16783           case 0xf1:
16784               GETBYTE ();
16785               switch (op[2] & 0xf0)
16786               {
16787                 case 0x00:
16788                 case 0x10:
16789                 case 0x20:
16790                 case 0x30:
16791                 case 0x40:
16792                 case 0x50:
16793                 case 0x60:
16794                 case 0x70:
16795                 case 0x80:
16796                 case 0x90:
16797                 case 0xa0:
16798                 case 0xb0:
16799                 case 0xc0:
16800                 case 0xd0:
16801                 case 0xe0:
16802                   goto op_semantics_139;
16803                   break;
16804                 case 0xf0:
16805                   goto op_semantics_140;
16806                   break;
16807               }
16808             break;
16809           case 0xf2:
16810               GETBYTE ();
16811               switch (op[2] & 0xf0)
16812               {
16813                 case 0x00:
16814                 case 0x10:
16815                 case 0x20:
16816                 case 0x30:
16817                 case 0x40:
16818                 case 0x50:
16819                 case 0x60:
16820                 case 0x70:
16821                 case 0x80:
16822                 case 0x90:
16823                 case 0xa0:
16824                 case 0xb0:
16825                 case 0xc0:
16826                 case 0xd0:
16827                 case 0xe0:
16828                   goto op_semantics_139;
16829                   break;
16830                 case 0xf0:
16831                   goto op_semantics_140;
16832                   break;
16833               }
16834             break;
16835           case 0xf3:
16836               GETBYTE ();
16837               switch (op[2] & 0xf0)
16838               {
16839                 case 0x00:
16840                 case 0x10:
16841                 case 0x20:
16842                 case 0x30:
16843                 case 0x40:
16844                 case 0x50:
16845                 case 0x60:
16846                 case 0x70:
16847                 case 0x80:
16848                 case 0x90:
16849                 case 0xa0:
16850                 case 0xb0:
16851                 case 0xc0:
16852                 case 0xd0:
16853                 case 0xe0:
16854                   goto op_semantics_139;
16855                   break;
16856                 case 0xf0:
16857                   goto op_semantics_140;
16858                   break;
16859               }
16860             break;
16861           case 0xf4:
16862               GETBYTE ();
16863               switch (op[2] & 0xf0)
16864               {
16865                 case 0x00:
16866                 case 0x10:
16867                 case 0x20:
16868                 case 0x30:
16869                 case 0x40:
16870                 case 0x50:
16871                 case 0x60:
16872                 case 0x70:
16873                 case 0x80:
16874                 case 0x90:
16875                 case 0xa0:
16876                 case 0xb0:
16877                 case 0xc0:
16878                 case 0xd0:
16879                 case 0xe0:
16880                   goto op_semantics_139;
16881                   break;
16882                 case 0xf0:
16883                   goto op_semantics_140;
16884                   break;
16885               }
16886             break;
16887           case 0xf5:
16888               GETBYTE ();
16889               switch (op[2] & 0xf0)
16890               {
16891                 case 0x00:
16892                 case 0x10:
16893                 case 0x20:
16894                 case 0x30:
16895                 case 0x40:
16896                 case 0x50:
16897                 case 0x60:
16898                 case 0x70:
16899                 case 0x80:
16900                 case 0x90:
16901                 case 0xa0:
16902                 case 0xb0:
16903                 case 0xc0:
16904                 case 0xd0:
16905                 case 0xe0:
16906                   goto op_semantics_139;
16907                   break;
16908                 case 0xf0:
16909                   goto op_semantics_140;
16910                   break;
16911               }
16912             break;
16913           case 0xf6:
16914               GETBYTE ();
16915               switch (op[2] & 0xf0)
16916               {
16917                 case 0x00:
16918                 case 0x10:
16919                 case 0x20:
16920                 case 0x30:
16921                 case 0x40:
16922                 case 0x50:
16923                 case 0x60:
16924                 case 0x70:
16925                 case 0x80:
16926                 case 0x90:
16927                 case 0xa0:
16928                 case 0xb0:
16929                 case 0xc0:
16930                 case 0xd0:
16931                 case 0xe0:
16932                   goto op_semantics_139;
16933                   break;
16934                 case 0xf0:
16935                   goto op_semantics_140;
16936                   break;
16937               }
16938             break;
16939           case 0xf7:
16940               GETBYTE ();
16941               switch (op[2] & 0xf0)
16942               {
16943                 case 0x00:
16944                 case 0x10:
16945                 case 0x20:
16946                 case 0x30:
16947                 case 0x40:
16948                 case 0x50:
16949                 case 0x60:
16950                 case 0x70:
16951                 case 0x80:
16952                 case 0x90:
16953                 case 0xa0:
16954                 case 0xb0:
16955                 case 0xc0:
16956                 case 0xd0:
16957                 case 0xe0:
16958                   goto op_semantics_139;
16959                   break;
16960                 case 0xf0:
16961                   goto op_semantics_140;
16962                   break;
16963               }
16964             break;
16965           case 0xf8:
16966               GETBYTE ();
16967               switch (op[2] & 0xf0)
16968               {
16969                 case 0x00:
16970                 case 0x10:
16971                 case 0x20:
16972                 case 0x30:
16973                 case 0x40:
16974                 case 0x50:
16975                 case 0x60:
16976                 case 0x70:
16977                 case 0x80:
16978                 case 0x90:
16979                 case 0xa0:
16980                 case 0xb0:
16981                 case 0xc0:
16982                 case 0xd0:
16983                 case 0xe0:
16984                   goto op_semantics_139;
16985                   break;
16986                 case 0xf0:
16987                   goto op_semantics_140;
16988                   break;
16989               }
16990             break;
16991           case 0xf9:
16992               GETBYTE ();
16993               switch (op[2] & 0xf0)
16994               {
16995                 case 0x00:
16996                 case 0x10:
16997                 case 0x20:
16998                 case 0x30:
16999                 case 0x40:
17000                 case 0x50:
17001                 case 0x60:
17002                 case 0x70:
17003                 case 0x80:
17004                 case 0x90:
17005                 case 0xa0:
17006                 case 0xb0:
17007                 case 0xc0:
17008                 case 0xd0:
17009                 case 0xe0:
17010                   goto op_semantics_139;
17011                   break;
17012                 case 0xf0:
17013                   goto op_semantics_140;
17014                   break;
17015               }
17016             break;
17017           case 0xfa:
17018               GETBYTE ();
17019               switch (op[2] & 0xf0)
17020               {
17021                 case 0x00:
17022                 case 0x10:
17023                 case 0x20:
17024                 case 0x30:
17025                 case 0x40:
17026                 case 0x50:
17027                 case 0x60:
17028                 case 0x70:
17029                 case 0x80:
17030                 case 0x90:
17031                 case 0xa0:
17032                 case 0xb0:
17033                 case 0xc0:
17034                 case 0xd0:
17035                 case 0xe0:
17036                   goto op_semantics_139;
17037                   break;
17038                 case 0xf0:
17039                   goto op_semantics_140;
17040                   break;
17041               }
17042             break;
17043           case 0xfb:
17044               GETBYTE ();
17045               switch (op[2] & 0xf0)
17046               {
17047                 case 0x00:
17048                 case 0x10:
17049                 case 0x20:
17050                 case 0x30:
17051                 case 0x40:
17052                 case 0x50:
17053                 case 0x60:
17054                 case 0x70:
17055                 case 0x80:
17056                 case 0x90:
17057                 case 0xa0:
17058                 case 0xb0:
17059                 case 0xc0:
17060                 case 0xd0:
17061                 case 0xe0:
17062                   goto op_semantics_139;
17063                   break;
17064                 case 0xf0:
17065                   goto op_semantics_140;
17066                   break;
17067               }
17068             break;
17069           case 0xfc:
17070               GETBYTE ();
17071               switch (op[2] & 0xf0)
17072               {
17073                 case 0x00:
17074                 case 0x10:
17075                 case 0x20:
17076                 case 0x30:
17077                 case 0x40:
17078                 case 0x50:
17079                 case 0x60:
17080                 case 0x70:
17081                 case 0x80:
17082                 case 0x90:
17083                 case 0xa0:
17084                 case 0xb0:
17085                 case 0xc0:
17086                 case 0xd0:
17087                 case 0xe0:
17088                   goto op_semantics_139;
17089                   break;
17090                 case 0xf0:
17091                   goto op_semantics_140;
17092                   break;
17093               }
17094             break;
17095           case 0xfd:
17096               GETBYTE ();
17097               switch (op[2] & 0xf0)
17098               {
17099                 case 0x00:
17100                 case 0x10:
17101                 case 0x20:
17102                 case 0x30:
17103                 case 0x40:
17104                 case 0x50:
17105                 case 0x60:
17106                 case 0x70:
17107                 case 0x80:
17108                 case 0x90:
17109                 case 0xa0:
17110                 case 0xb0:
17111                 case 0xc0:
17112                 case 0xd0:
17113                 case 0xe0:
17114                   goto op_semantics_139;
17115                   break;
17116                 case 0xf0:
17117                   goto op_semantics_140;
17118                   break;
17119               }
17120             break;
17121           case 0xfe:
17122               GETBYTE ();
17123               switch (op[2] & 0xf0)
17124               {
17125                 case 0x00:
17126                 case 0x10:
17127                 case 0x20:
17128                 case 0x30:
17129                 case 0x40:
17130                 case 0x50:
17131                 case 0x60:
17132                 case 0x70:
17133                 case 0x80:
17134                 case 0x90:
17135                 case 0xa0:
17136                 case 0xb0:
17137                 case 0xc0:
17138                 case 0xd0:
17139                 case 0xe0:
17140                   goto op_semantics_139;
17141                   break;
17142                 case 0xf0:
17143                   goto op_semantics_140;
17144                   break;
17145               }
17146             break;
17147           case 0xff:
17148               GETBYTE ();
17149               switch (op[2] & 0xf0)
17150               {
17151                 case 0x00:
17152                 case 0x10:
17153                 case 0x20:
17154                 case 0x30:
17155                 case 0x40:
17156                 case 0x50:
17157                 case 0x60:
17158                 case 0x70:
17159                 case 0x80:
17160                 case 0x90:
17161                 case 0xa0:
17162                 case 0xb0:
17163                 case 0xc0:
17164                 case 0xd0:
17165                 case 0xe0:
17166                   goto op_semantics_139;
17167                   break;
17168                 case 0xf0:
17169                   goto op_semantics_140;
17170                   break;
17171               }
17172             break;
17173           default: UNSUPPORTED(); break;
17174         }
17175       break;
17176     case 0xfe:
17177         GETBYTE ();
17178         switch (op[1] & 0xff)
17179         {
17180           case 0x00:
17181               GETBYTE ();
17182               switch (op[2] & 0x00)
17183               {
17184                 case 0x00:
17185                   op_semantics_141:
17186                     {
17187                       /** 1111 1110 00sz isrc bsrc rdst mov%s   %0, [%1, %2] */
17188 #line 363 "rx-decode.opc"
17189                       int sz AU = (op[1] >> 4) & 0x03;
17190 #line 363 "rx-decode.opc"
17191                       int isrc AU = op[1] & 0x0f;
17192 #line 363 "rx-decode.opc"
17193                       int bsrc AU = (op[2] >> 4) & 0x0f;
17194 #line 363 "rx-decode.opc"
17195                       int rdst AU = op[2] & 0x0f;
17196                       if (trace)
17197                         {
17198                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17199                                  "/** 1111 1110 00sz isrc bsrc rdst     mov%s   %0, [%1, %2] */",
17200                                  op[0], op[1], op[2]);
17201                           printf ("  sz = 0x%x,", sz);
17202                           printf ("  isrc = 0x%x,", isrc);
17203                           printf ("  bsrc = 0x%x,", bsrc);
17204                           printf ("  rdst = 0x%x\n", rdst);
17205                         }
17206                       SYNTAX("mov%s     %0, [%1, %2]");
17207 #line 363 "rx-decode.opc"
17208                       ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17209
17210                     }
17211                   break;
17212               }
17213             break;
17214           case 0x01:
17215               GETBYTE ();
17216               switch (op[2] & 0x00)
17217               {
17218                 case 0x00:
17219                   goto op_semantics_141;
17220                   break;
17221               }
17222             break;
17223           case 0x02:
17224               GETBYTE ();
17225               switch (op[2] & 0x00)
17226               {
17227                 case 0x00:
17228                   goto op_semantics_141;
17229                   break;
17230               }
17231             break;
17232           case 0x03:
17233               GETBYTE ();
17234               switch (op[2] & 0x00)
17235               {
17236                 case 0x00:
17237                   goto op_semantics_141;
17238                   break;
17239               }
17240             break;
17241           case 0x04:
17242               GETBYTE ();
17243               switch (op[2] & 0x00)
17244               {
17245                 case 0x00:
17246                   goto op_semantics_141;
17247                   break;
17248               }
17249             break;
17250           case 0x05:
17251               GETBYTE ();
17252               switch (op[2] & 0x00)
17253               {
17254                 case 0x00:
17255                   goto op_semantics_141;
17256                   break;
17257               }
17258             break;
17259           case 0x06:
17260               GETBYTE ();
17261               switch (op[2] & 0x00)
17262               {
17263                 case 0x00:
17264                   goto op_semantics_141;
17265                   break;
17266               }
17267             break;
17268           case 0x07:
17269               GETBYTE ();
17270               switch (op[2] & 0x00)
17271               {
17272                 case 0x00:
17273                   goto op_semantics_141;
17274                   break;
17275               }
17276             break;
17277           case 0x08:
17278               GETBYTE ();
17279               switch (op[2] & 0x00)
17280               {
17281                 case 0x00:
17282                   goto op_semantics_141;
17283                   break;
17284               }
17285             break;
17286           case 0x09:
17287               GETBYTE ();
17288               switch (op[2] & 0x00)
17289               {
17290                 case 0x00:
17291                   goto op_semantics_141;
17292                   break;
17293               }
17294             break;
17295           case 0x0a:
17296               GETBYTE ();
17297               switch (op[2] & 0x00)
17298               {
17299                 case 0x00:
17300                   goto op_semantics_141;
17301                   break;
17302               }
17303             break;
17304           case 0x0b:
17305               GETBYTE ();
17306               switch (op[2] & 0x00)
17307               {
17308                 case 0x00:
17309                   goto op_semantics_141;
17310                   break;
17311               }
17312             break;
17313           case 0x0c:
17314               GETBYTE ();
17315               switch (op[2] & 0x00)
17316               {
17317                 case 0x00:
17318                   goto op_semantics_141;
17319                   break;
17320               }
17321             break;
17322           case 0x0d:
17323               GETBYTE ();
17324               switch (op[2] & 0x00)
17325               {
17326                 case 0x00:
17327                   goto op_semantics_141;
17328                   break;
17329               }
17330             break;
17331           case 0x0e:
17332               GETBYTE ();
17333               switch (op[2] & 0x00)
17334               {
17335                 case 0x00:
17336                   goto op_semantics_141;
17337                   break;
17338               }
17339             break;
17340           case 0x0f:
17341               GETBYTE ();
17342               switch (op[2] & 0x00)
17343               {
17344                 case 0x00:
17345                   goto op_semantics_141;
17346                   break;
17347               }
17348             break;
17349           case 0x10:
17350               GETBYTE ();
17351               switch (op[2] & 0x00)
17352               {
17353                 case 0x00:
17354                   goto op_semantics_141;
17355                   break;
17356               }
17357             break;
17358           case 0x11:
17359               GETBYTE ();
17360               switch (op[2] & 0x00)
17361               {
17362                 case 0x00:
17363                   goto op_semantics_141;
17364                   break;
17365               }
17366             break;
17367           case 0x12:
17368               GETBYTE ();
17369               switch (op[2] & 0x00)
17370               {
17371                 case 0x00:
17372                   goto op_semantics_141;
17373                   break;
17374               }
17375             break;
17376           case 0x13:
17377               GETBYTE ();
17378               switch (op[2] & 0x00)
17379               {
17380                 case 0x00:
17381                   goto op_semantics_141;
17382                   break;
17383               }
17384             break;
17385           case 0x14:
17386               GETBYTE ();
17387               switch (op[2] & 0x00)
17388               {
17389                 case 0x00:
17390                   goto op_semantics_141;
17391                   break;
17392               }
17393             break;
17394           case 0x15:
17395               GETBYTE ();
17396               switch (op[2] & 0x00)
17397               {
17398                 case 0x00:
17399                   goto op_semantics_141;
17400                   break;
17401               }
17402             break;
17403           case 0x16:
17404               GETBYTE ();
17405               switch (op[2] & 0x00)
17406               {
17407                 case 0x00:
17408                   goto op_semantics_141;
17409                   break;
17410               }
17411             break;
17412           case 0x17:
17413               GETBYTE ();
17414               switch (op[2] & 0x00)
17415               {
17416                 case 0x00:
17417                   goto op_semantics_141;
17418                   break;
17419               }
17420             break;
17421           case 0x18:
17422               GETBYTE ();
17423               switch (op[2] & 0x00)
17424               {
17425                 case 0x00:
17426                   goto op_semantics_141;
17427                   break;
17428               }
17429             break;
17430           case 0x19:
17431               GETBYTE ();
17432               switch (op[2] & 0x00)
17433               {
17434                 case 0x00:
17435                   goto op_semantics_141;
17436                   break;
17437               }
17438             break;
17439           case 0x1a:
17440               GETBYTE ();
17441               switch (op[2] & 0x00)
17442               {
17443                 case 0x00:
17444                   goto op_semantics_141;
17445                   break;
17446               }
17447             break;
17448           case 0x1b:
17449               GETBYTE ();
17450               switch (op[2] & 0x00)
17451               {
17452                 case 0x00:
17453                   goto op_semantics_141;
17454                   break;
17455               }
17456             break;
17457           case 0x1c:
17458               GETBYTE ();
17459               switch (op[2] & 0x00)
17460               {
17461                 case 0x00:
17462                   goto op_semantics_141;
17463                   break;
17464               }
17465             break;
17466           case 0x1d:
17467               GETBYTE ();
17468               switch (op[2] & 0x00)
17469               {
17470                 case 0x00:
17471                   goto op_semantics_141;
17472                   break;
17473               }
17474             break;
17475           case 0x1e:
17476               GETBYTE ();
17477               switch (op[2] & 0x00)
17478               {
17479                 case 0x00:
17480                   goto op_semantics_141;
17481                   break;
17482               }
17483             break;
17484           case 0x1f:
17485               GETBYTE ();
17486               switch (op[2] & 0x00)
17487               {
17488                 case 0x00:
17489                   goto op_semantics_141;
17490                   break;
17491               }
17492             break;
17493           case 0x20:
17494               GETBYTE ();
17495               switch (op[2] & 0x00)
17496               {
17497                 case 0x00:
17498                   goto op_semantics_141;
17499                   break;
17500               }
17501             break;
17502           case 0x21:
17503               GETBYTE ();
17504               switch (op[2] & 0x00)
17505               {
17506                 case 0x00:
17507                   goto op_semantics_141;
17508                   break;
17509               }
17510             break;
17511           case 0x22:
17512               GETBYTE ();
17513               switch (op[2] & 0x00)
17514               {
17515                 case 0x00:
17516                   goto op_semantics_141;
17517                   break;
17518               }
17519             break;
17520           case 0x23:
17521               GETBYTE ();
17522               switch (op[2] & 0x00)
17523               {
17524                 case 0x00:
17525                   goto op_semantics_141;
17526                   break;
17527               }
17528             break;
17529           case 0x24:
17530               GETBYTE ();
17531               switch (op[2] & 0x00)
17532               {
17533                 case 0x00:
17534                   goto op_semantics_141;
17535                   break;
17536               }
17537             break;
17538           case 0x25:
17539               GETBYTE ();
17540               switch (op[2] & 0x00)
17541               {
17542                 case 0x00:
17543                   goto op_semantics_141;
17544                   break;
17545               }
17546             break;
17547           case 0x26:
17548               GETBYTE ();
17549               switch (op[2] & 0x00)
17550               {
17551                 case 0x00:
17552                   goto op_semantics_141;
17553                   break;
17554               }
17555             break;
17556           case 0x27:
17557               GETBYTE ();
17558               switch (op[2] & 0x00)
17559               {
17560                 case 0x00:
17561                   goto op_semantics_141;
17562                   break;
17563               }
17564             break;
17565           case 0x28:
17566               GETBYTE ();
17567               switch (op[2] & 0x00)
17568               {
17569                 case 0x00:
17570                   goto op_semantics_141;
17571                   break;
17572               }
17573             break;
17574           case 0x29:
17575               GETBYTE ();
17576               switch (op[2] & 0x00)
17577               {
17578                 case 0x00:
17579                   goto op_semantics_141;
17580                   break;
17581               }
17582             break;
17583           case 0x2a:
17584               GETBYTE ();
17585               switch (op[2] & 0x00)
17586               {
17587                 case 0x00:
17588                   goto op_semantics_141;
17589                   break;
17590               }
17591             break;
17592           case 0x2b:
17593               GETBYTE ();
17594               switch (op[2] & 0x00)
17595               {
17596                 case 0x00:
17597                   goto op_semantics_141;
17598                   break;
17599               }
17600             break;
17601           case 0x2c:
17602               GETBYTE ();
17603               switch (op[2] & 0x00)
17604               {
17605                 case 0x00:
17606                   goto op_semantics_141;
17607                   break;
17608               }
17609             break;
17610           case 0x2d:
17611               GETBYTE ();
17612               switch (op[2] & 0x00)
17613               {
17614                 case 0x00:
17615                   goto op_semantics_141;
17616                   break;
17617               }
17618             break;
17619           case 0x2e:
17620               GETBYTE ();
17621               switch (op[2] & 0x00)
17622               {
17623                 case 0x00:
17624                   goto op_semantics_141;
17625                   break;
17626               }
17627             break;
17628           case 0x2f:
17629               GETBYTE ();
17630               switch (op[2] & 0x00)
17631               {
17632                 case 0x00:
17633                   goto op_semantics_141;
17634                   break;
17635               }
17636             break;
17637           case 0x40:
17638               GETBYTE ();
17639               switch (op[2] & 0x00)
17640               {
17641                 case 0x00:
17642                   op_semantics_142:
17643                     {
17644                       /** 1111 1110 01sz isrc bsrc rdst mov%s   [%1, %2], %0 */
17645 #line 360 "rx-decode.opc"
17646                       int sz AU = (op[1] >> 4) & 0x03;
17647 #line 360 "rx-decode.opc"
17648                       int isrc AU = op[1] & 0x0f;
17649 #line 360 "rx-decode.opc"
17650                       int bsrc AU = (op[2] >> 4) & 0x0f;
17651 #line 360 "rx-decode.opc"
17652                       int rdst AU = op[2] & 0x0f;
17653                       if (trace)
17654                         {
17655                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
17656                                  "/** 1111 1110 01sz isrc bsrc rdst     mov%s   [%1, %2], %0 */",
17657                                  op[0], op[1], op[2]);
17658                           printf ("  sz = 0x%x,", sz);
17659                           printf ("  isrc = 0x%x,", isrc);
17660                           printf ("  bsrc = 0x%x,", bsrc);
17661                           printf ("  rdst = 0x%x\n", rdst);
17662                         }
17663                       SYNTAX("mov%s     [%1, %2], %0");
17664 #line 360 "rx-decode.opc"
17665                       ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
17666
17667                     }
17668                   break;
17669               }
17670             break;
17671           case 0x41:
17672               GETBYTE ();
17673               switch (op[2] & 0x00)
17674               {
17675                 case 0x00:
17676                   goto op_semantics_142;
17677                   break;
17678               }
17679             break;
17680           case 0x42:
17681               GETBYTE ();
17682               switch (op[2] & 0x00)
17683               {
17684                 case 0x00:
17685                   goto op_semantics_142;
17686                   break;
17687               }
17688             break;
17689           case 0x43:
17690               GETBYTE ();
17691               switch (op[2] & 0x00)
17692               {
17693                 case 0x00:
17694                   goto op_semantics_142;
17695                   break;
17696               }
17697             break;
17698           case 0x44:
17699               GETBYTE ();
17700               switch (op[2] & 0x00)
17701               {
17702                 case 0x00:
17703                   goto op_semantics_142;
17704                   break;
17705               }
17706             break;
17707           case 0x45:
17708               GETBYTE ();
17709               switch (op[2] & 0x00)
17710               {
17711                 case 0x00:
17712                   goto op_semantics_142;
17713                   break;
17714               }
17715             break;
17716           case 0x46:
17717               GETBYTE ();
17718               switch (op[2] & 0x00)
17719               {
17720                 case 0x00:
17721                   goto op_semantics_142;
17722                   break;
17723               }
17724             break;
17725           case 0x47:
17726               GETBYTE ();
17727               switch (op[2] & 0x00)
17728               {
17729                 case 0x00:
17730                   goto op_semantics_142;
17731                   break;
17732               }
17733             break;
17734           case 0x48:
17735               GETBYTE ();
17736               switch (op[2] & 0x00)
17737               {
17738                 case 0x00:
17739                   goto op_semantics_142;
17740                   break;
17741               }
17742             break;
17743           case 0x49:
17744               GETBYTE ();
17745               switch (op[2] & 0x00)
17746               {
17747                 case 0x00:
17748                   goto op_semantics_142;
17749                   break;
17750               }
17751             break;
17752           case 0x4a:
17753               GETBYTE ();
17754               switch (op[2] & 0x00)
17755               {
17756                 case 0x00:
17757                   goto op_semantics_142;
17758                   break;
17759               }
17760             break;
17761           case 0x4b:
17762               GETBYTE ();
17763               switch (op[2] & 0x00)
17764               {
17765                 case 0x00:
17766                   goto op_semantics_142;
17767                   break;
17768               }
17769             break;
17770           case 0x4c:
17771               GETBYTE ();
17772               switch (op[2] & 0x00)
17773               {
17774                 case 0x00:
17775                   goto op_semantics_142;
17776                   break;
17777               }
17778             break;
17779           case 0x4d:
17780               GETBYTE ();
17781               switch (op[2] & 0x00)
17782               {
17783                 case 0x00:
17784                   goto op_semantics_142;
17785                   break;
17786               }
17787             break;
17788           case 0x4e:
17789               GETBYTE ();
17790               switch (op[2] & 0x00)
17791               {
17792                 case 0x00:
17793                   goto op_semantics_142;
17794                   break;
17795               }
17796             break;
17797           case 0x4f:
17798               GETBYTE ();
17799               switch (op[2] & 0x00)
17800               {
17801                 case 0x00:
17802                   goto op_semantics_142;
17803                   break;
17804               }
17805             break;
17806           case 0x50:
17807               GETBYTE ();
17808               switch (op[2] & 0x00)
17809               {
17810                 case 0x00:
17811                   goto op_semantics_142;
17812                   break;
17813               }
17814             break;
17815           case 0x51:
17816               GETBYTE ();
17817               switch (op[2] & 0x00)
17818               {
17819                 case 0x00:
17820                   goto op_semantics_142;
17821                   break;
17822               }
17823             break;
17824           case 0x52:
17825               GETBYTE ();
17826               switch (op[2] & 0x00)
17827               {
17828                 case 0x00:
17829                   goto op_semantics_142;
17830                   break;
17831               }
17832             break;
17833           case 0x53:
17834               GETBYTE ();
17835               switch (op[2] & 0x00)
17836               {
17837                 case 0x00:
17838                   goto op_semantics_142;
17839                   break;
17840               }
17841             break;
17842           case 0x54:
17843               GETBYTE ();
17844               switch (op[2] & 0x00)
17845               {
17846                 case 0x00:
17847                   goto op_semantics_142;
17848                   break;
17849               }
17850             break;
17851           case 0x55:
17852               GETBYTE ();
17853               switch (op[2] & 0x00)
17854               {
17855                 case 0x00:
17856                   goto op_semantics_142;
17857                   break;
17858               }
17859             break;
17860           case 0x56:
17861               GETBYTE ();
17862               switch (op[2] & 0x00)
17863               {
17864                 case 0x00:
17865                   goto op_semantics_142;
17866                   break;
17867               }
17868             break;
17869           case 0x57:
17870               GETBYTE ();
17871               switch (op[2] & 0x00)
17872               {
17873                 case 0x00:
17874                   goto op_semantics_142;
17875                   break;
17876               }
17877             break;
17878           case 0x58:
17879               GETBYTE ();
17880               switch (op[2] & 0x00)
17881               {
17882                 case 0x00:
17883                   goto op_semantics_142;
17884                   break;
17885               }
17886             break;
17887           case 0x59:
17888               GETBYTE ();
17889               switch (op[2] & 0x00)
17890               {
17891                 case 0x00:
17892                   goto op_semantics_142;
17893                   break;
17894               }
17895             break;
17896           case 0x5a:
17897               GETBYTE ();
17898               switch (op[2] & 0x00)
17899               {
17900                 case 0x00:
17901                   goto op_semantics_142;
17902                   break;
17903               }
17904             break;
17905           case 0x5b:
17906               GETBYTE ();
17907               switch (op[2] & 0x00)
17908               {
17909                 case 0x00:
17910                   goto op_semantics_142;
17911                   break;
17912               }
17913             break;
17914           case 0x5c:
17915               GETBYTE ();
17916               switch (op[2] & 0x00)
17917               {
17918                 case 0x00:
17919                   goto op_semantics_142;
17920                   break;
17921               }
17922             break;
17923           case 0x5d:
17924               GETBYTE ();
17925               switch (op[2] & 0x00)
17926               {
17927                 case 0x00:
17928                   goto op_semantics_142;
17929                   break;
17930               }
17931             break;
17932           case 0x5e:
17933               GETBYTE ();
17934               switch (op[2] & 0x00)
17935               {
17936                 case 0x00:
17937                   goto op_semantics_142;
17938                   break;
17939               }
17940             break;
17941           case 0x5f:
17942               GETBYTE ();
17943               switch (op[2] & 0x00)
17944               {
17945                 case 0x00:
17946                   goto op_semantics_142;
17947                   break;
17948               }
17949             break;
17950           case 0x60:
17951               GETBYTE ();
17952               switch (op[2] & 0x00)
17953               {
17954                 case 0x00:
17955                   goto op_semantics_142;
17956                   break;
17957               }
17958             break;
17959           case 0x61:
17960               GETBYTE ();
17961               switch (op[2] & 0x00)
17962               {
17963                 case 0x00:
17964                   goto op_semantics_142;
17965                   break;
17966               }
17967             break;
17968           case 0x62:
17969               GETBYTE ();
17970               switch (op[2] & 0x00)
17971               {
17972                 case 0x00:
17973                   goto op_semantics_142;
17974                   break;
17975               }
17976             break;
17977           case 0x63:
17978               GETBYTE ();
17979               switch (op[2] & 0x00)
17980               {
17981                 case 0x00:
17982                   goto op_semantics_142;
17983                   break;
17984               }
17985             break;
17986           case 0x64:
17987               GETBYTE ();
17988               switch (op[2] & 0x00)
17989               {
17990                 case 0x00:
17991                   goto op_semantics_142;
17992                   break;
17993               }
17994             break;
17995           case 0x65:
17996               GETBYTE ();
17997               switch (op[2] & 0x00)
17998               {
17999                 case 0x00:
18000                   goto op_semantics_142;
18001                   break;
18002               }
18003             break;
18004           case 0x66:
18005               GETBYTE ();
18006               switch (op[2] & 0x00)
18007               {
18008                 case 0x00:
18009                   goto op_semantics_142;
18010                   break;
18011               }
18012             break;
18013           case 0x67:
18014               GETBYTE ();
18015               switch (op[2] & 0x00)
18016               {
18017                 case 0x00:
18018                   goto op_semantics_142;
18019                   break;
18020               }
18021             break;
18022           case 0x68:
18023               GETBYTE ();
18024               switch (op[2] & 0x00)
18025               {
18026                 case 0x00:
18027                   goto op_semantics_142;
18028                   break;
18029               }
18030             break;
18031           case 0x69:
18032               GETBYTE ();
18033               switch (op[2] & 0x00)
18034               {
18035                 case 0x00:
18036                   goto op_semantics_142;
18037                   break;
18038               }
18039             break;
18040           case 0x6a:
18041               GETBYTE ();
18042               switch (op[2] & 0x00)
18043               {
18044                 case 0x00:
18045                   goto op_semantics_142;
18046                   break;
18047               }
18048             break;
18049           case 0x6b:
18050               GETBYTE ();
18051               switch (op[2] & 0x00)
18052               {
18053                 case 0x00:
18054                   goto op_semantics_142;
18055                   break;
18056               }
18057             break;
18058           case 0x6c:
18059               GETBYTE ();
18060               switch (op[2] & 0x00)
18061               {
18062                 case 0x00:
18063                   goto op_semantics_142;
18064                   break;
18065               }
18066             break;
18067           case 0x6d:
18068               GETBYTE ();
18069               switch (op[2] & 0x00)
18070               {
18071                 case 0x00:
18072                   goto op_semantics_142;
18073                   break;
18074               }
18075             break;
18076           case 0x6e:
18077               GETBYTE ();
18078               switch (op[2] & 0x00)
18079               {
18080                 case 0x00:
18081                   goto op_semantics_142;
18082                   break;
18083               }
18084             break;
18085           case 0x6f:
18086               GETBYTE ();
18087               switch (op[2] & 0x00)
18088               {
18089                 case 0x00:
18090                   goto op_semantics_142;
18091                   break;
18092               }
18093             break;
18094           case 0xc0:
18095               GETBYTE ();
18096               switch (op[2] & 0x00)
18097               {
18098                 case 0x00:
18099                   op_semantics_143:
18100                     {
18101                       /** 1111 1110 11sz isrc bsrc rdst movu%s  [%1, %2], %0 */
18102 #line 366 "rx-decode.opc"
18103                       int sz AU = (op[1] >> 4) & 0x03;
18104 #line 366 "rx-decode.opc"
18105                       int isrc AU = op[1] & 0x0f;
18106 #line 366 "rx-decode.opc"
18107                       int bsrc AU = (op[2] >> 4) & 0x0f;
18108 #line 366 "rx-decode.opc"
18109                       int rdst AU = op[2] & 0x0f;
18110                       if (trace)
18111                         {
18112                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18113                                  "/** 1111 1110 11sz isrc bsrc rdst     movu%s  [%1, %2], %0 */",
18114                                  op[0], op[1], op[2]);
18115                           printf ("  sz = 0x%x,", sz);
18116                           printf ("  isrc = 0x%x,", isrc);
18117                           printf ("  bsrc = 0x%x,", bsrc);
18118                           printf ("  rdst = 0x%x\n", rdst);
18119                         }
18120                       SYNTAX("movu%s    [%1, %2], %0");
18121 #line 366 "rx-decode.opc"
18122                       ID(movbi); uBW(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
18123
18124                     }
18125                   break;
18126               }
18127             break;
18128           case 0xc1:
18129               GETBYTE ();
18130               switch (op[2] & 0x00)
18131               {
18132                 case 0x00:
18133                   goto op_semantics_143;
18134                   break;
18135               }
18136             break;
18137           case 0xc2:
18138               GETBYTE ();
18139               switch (op[2] & 0x00)
18140               {
18141                 case 0x00:
18142                   goto op_semantics_143;
18143                   break;
18144               }
18145             break;
18146           case 0xc3:
18147               GETBYTE ();
18148               switch (op[2] & 0x00)
18149               {
18150                 case 0x00:
18151                   goto op_semantics_143;
18152                   break;
18153               }
18154             break;
18155           case 0xc4:
18156               GETBYTE ();
18157               switch (op[2] & 0x00)
18158               {
18159                 case 0x00:
18160                   goto op_semantics_143;
18161                   break;
18162               }
18163             break;
18164           case 0xc5:
18165               GETBYTE ();
18166               switch (op[2] & 0x00)
18167               {
18168                 case 0x00:
18169                   goto op_semantics_143;
18170                   break;
18171               }
18172             break;
18173           case 0xc6:
18174               GETBYTE ();
18175               switch (op[2] & 0x00)
18176               {
18177                 case 0x00:
18178                   goto op_semantics_143;
18179                   break;
18180               }
18181             break;
18182           case 0xc7:
18183               GETBYTE ();
18184               switch (op[2] & 0x00)
18185               {
18186                 case 0x00:
18187                   goto op_semantics_143;
18188                   break;
18189               }
18190             break;
18191           case 0xc8:
18192               GETBYTE ();
18193               switch (op[2] & 0x00)
18194               {
18195                 case 0x00:
18196                   goto op_semantics_143;
18197                   break;
18198               }
18199             break;
18200           case 0xc9:
18201               GETBYTE ();
18202               switch (op[2] & 0x00)
18203               {
18204                 case 0x00:
18205                   goto op_semantics_143;
18206                   break;
18207               }
18208             break;
18209           case 0xca:
18210               GETBYTE ();
18211               switch (op[2] & 0x00)
18212               {
18213                 case 0x00:
18214                   goto op_semantics_143;
18215                   break;
18216               }
18217             break;
18218           case 0xcb:
18219               GETBYTE ();
18220               switch (op[2] & 0x00)
18221               {
18222                 case 0x00:
18223                   goto op_semantics_143;
18224                   break;
18225               }
18226             break;
18227           case 0xcc:
18228               GETBYTE ();
18229               switch (op[2] & 0x00)
18230               {
18231                 case 0x00:
18232                   goto op_semantics_143;
18233                   break;
18234               }
18235             break;
18236           case 0xcd:
18237               GETBYTE ();
18238               switch (op[2] & 0x00)
18239               {
18240                 case 0x00:
18241                   goto op_semantics_143;
18242                   break;
18243               }
18244             break;
18245           case 0xce:
18246               GETBYTE ();
18247               switch (op[2] & 0x00)
18248               {
18249                 case 0x00:
18250                   goto op_semantics_143;
18251                   break;
18252               }
18253             break;
18254           case 0xcf:
18255               GETBYTE ();
18256               switch (op[2] & 0x00)
18257               {
18258                 case 0x00:
18259                   goto op_semantics_143;
18260                   break;
18261               }
18262             break;
18263           case 0xd0:
18264               GETBYTE ();
18265               switch (op[2] & 0x00)
18266               {
18267                 case 0x00:
18268                   goto op_semantics_143;
18269                   break;
18270               }
18271             break;
18272           case 0xd1:
18273               GETBYTE ();
18274               switch (op[2] & 0x00)
18275               {
18276                 case 0x00:
18277                   goto op_semantics_143;
18278                   break;
18279               }
18280             break;
18281           case 0xd2:
18282               GETBYTE ();
18283               switch (op[2] & 0x00)
18284               {
18285                 case 0x00:
18286                   goto op_semantics_143;
18287                   break;
18288               }
18289             break;
18290           case 0xd3:
18291               GETBYTE ();
18292               switch (op[2] & 0x00)
18293               {
18294                 case 0x00:
18295                   goto op_semantics_143;
18296                   break;
18297               }
18298             break;
18299           case 0xd4:
18300               GETBYTE ();
18301               switch (op[2] & 0x00)
18302               {
18303                 case 0x00:
18304                   goto op_semantics_143;
18305                   break;
18306               }
18307             break;
18308           case 0xd5:
18309               GETBYTE ();
18310               switch (op[2] & 0x00)
18311               {
18312                 case 0x00:
18313                   goto op_semantics_143;
18314                   break;
18315               }
18316             break;
18317           case 0xd6:
18318               GETBYTE ();
18319               switch (op[2] & 0x00)
18320               {
18321                 case 0x00:
18322                   goto op_semantics_143;
18323                   break;
18324               }
18325             break;
18326           case 0xd7:
18327               GETBYTE ();
18328               switch (op[2] & 0x00)
18329               {
18330                 case 0x00:
18331                   goto op_semantics_143;
18332                   break;
18333               }
18334             break;
18335           case 0xd8:
18336               GETBYTE ();
18337               switch (op[2] & 0x00)
18338               {
18339                 case 0x00:
18340                   goto op_semantics_143;
18341                   break;
18342               }
18343             break;
18344           case 0xd9:
18345               GETBYTE ();
18346               switch (op[2] & 0x00)
18347               {
18348                 case 0x00:
18349                   goto op_semantics_143;
18350                   break;
18351               }
18352             break;
18353           case 0xda:
18354               GETBYTE ();
18355               switch (op[2] & 0x00)
18356               {
18357                 case 0x00:
18358                   goto op_semantics_143;
18359                   break;
18360               }
18361             break;
18362           case 0xdb:
18363               GETBYTE ();
18364               switch (op[2] & 0x00)
18365               {
18366                 case 0x00:
18367                   goto op_semantics_143;
18368                   break;
18369               }
18370             break;
18371           case 0xdc:
18372               GETBYTE ();
18373               switch (op[2] & 0x00)
18374               {
18375                 case 0x00:
18376                   goto op_semantics_143;
18377                   break;
18378               }
18379             break;
18380           case 0xdd:
18381               GETBYTE ();
18382               switch (op[2] & 0x00)
18383               {
18384                 case 0x00:
18385                   goto op_semantics_143;
18386                   break;
18387               }
18388             break;
18389           case 0xde:
18390               GETBYTE ();
18391               switch (op[2] & 0x00)
18392               {
18393                 case 0x00:
18394                   goto op_semantics_143;
18395                   break;
18396               }
18397             break;
18398           case 0xdf:
18399               GETBYTE ();
18400               switch (op[2] & 0x00)
18401               {
18402                 case 0x00:
18403                   goto op_semantics_143;
18404                   break;
18405               }
18406             break;
18407           case 0xe0:
18408               GETBYTE ();
18409               switch (op[2] & 0x00)
18410               {
18411                 case 0x00:
18412                   goto op_semantics_143;
18413                   break;
18414               }
18415             break;
18416           case 0xe1:
18417               GETBYTE ();
18418               switch (op[2] & 0x00)
18419               {
18420                 case 0x00:
18421                   goto op_semantics_143;
18422                   break;
18423               }
18424             break;
18425           case 0xe2:
18426               GETBYTE ();
18427               switch (op[2] & 0x00)
18428               {
18429                 case 0x00:
18430                   goto op_semantics_143;
18431                   break;
18432               }
18433             break;
18434           case 0xe3:
18435               GETBYTE ();
18436               switch (op[2] & 0x00)
18437               {
18438                 case 0x00:
18439                   goto op_semantics_143;
18440                   break;
18441               }
18442             break;
18443           case 0xe4:
18444               GETBYTE ();
18445               switch (op[2] & 0x00)
18446               {
18447                 case 0x00:
18448                   goto op_semantics_143;
18449                   break;
18450               }
18451             break;
18452           case 0xe5:
18453               GETBYTE ();
18454               switch (op[2] & 0x00)
18455               {
18456                 case 0x00:
18457                   goto op_semantics_143;
18458                   break;
18459               }
18460             break;
18461           case 0xe6:
18462               GETBYTE ();
18463               switch (op[2] & 0x00)
18464               {
18465                 case 0x00:
18466                   goto op_semantics_143;
18467                   break;
18468               }
18469             break;
18470           case 0xe7:
18471               GETBYTE ();
18472               switch (op[2] & 0x00)
18473               {
18474                 case 0x00:
18475                   goto op_semantics_143;
18476                   break;
18477               }
18478             break;
18479           case 0xe8:
18480               GETBYTE ();
18481               switch (op[2] & 0x00)
18482               {
18483                 case 0x00:
18484                   goto op_semantics_143;
18485                   break;
18486               }
18487             break;
18488           case 0xe9:
18489               GETBYTE ();
18490               switch (op[2] & 0x00)
18491               {
18492                 case 0x00:
18493                   goto op_semantics_143;
18494                   break;
18495               }
18496             break;
18497           case 0xea:
18498               GETBYTE ();
18499               switch (op[2] & 0x00)
18500               {
18501                 case 0x00:
18502                   goto op_semantics_143;
18503                   break;
18504               }
18505             break;
18506           case 0xeb:
18507               GETBYTE ();
18508               switch (op[2] & 0x00)
18509               {
18510                 case 0x00:
18511                   goto op_semantics_143;
18512                   break;
18513               }
18514             break;
18515           case 0xec:
18516               GETBYTE ();
18517               switch (op[2] & 0x00)
18518               {
18519                 case 0x00:
18520                   goto op_semantics_143;
18521                   break;
18522               }
18523             break;
18524           case 0xed:
18525               GETBYTE ();
18526               switch (op[2] & 0x00)
18527               {
18528                 case 0x00:
18529                   goto op_semantics_143;
18530                   break;
18531               }
18532             break;
18533           case 0xee:
18534               GETBYTE ();
18535               switch (op[2] & 0x00)
18536               {
18537                 case 0x00:
18538                   goto op_semantics_143;
18539                   break;
18540               }
18541             break;
18542           case 0xef:
18543               GETBYTE ();
18544               switch (op[2] & 0x00)
18545               {
18546                 case 0x00:
18547                   goto op_semantics_143;
18548                   break;
18549               }
18550             break;
18551           default: UNSUPPORTED(); break;
18552         }
18553       break;
18554     case 0xff:
18555         GETBYTE ();
18556         switch (op[1] & 0xff)
18557         {
18558           case 0x00:
18559               GETBYTE ();
18560               switch (op[2] & 0x00)
18561               {
18562                 case 0x00:
18563                   op_semantics_144:
18564                     {
18565                       /** 1111 1111 0000 rdst srca srcb sub     %2, %1, %0 */
18566 #line 570 "rx-decode.opc"
18567                       int rdst AU = op[1] & 0x0f;
18568 #line 570 "rx-decode.opc"
18569                       int srca AU = (op[2] >> 4) & 0x0f;
18570 #line 570 "rx-decode.opc"
18571                       int srcb AU = op[2] & 0x0f;
18572                       if (trace)
18573                         {
18574                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18575                                  "/** 1111 1111 0000 rdst srca srcb     sub     %2, %1, %0 */",
18576                                  op[0], op[1], op[2]);
18577                           printf ("  rdst = 0x%x,", rdst);
18578                           printf ("  srca = 0x%x,", srca);
18579                           printf ("  srcb = 0x%x\n", srcb);
18580                         }
18581                       SYNTAX("sub       %2, %1, %0");
18582 #line 570 "rx-decode.opc"
18583                       ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18584
18585                     /*----------------------------------------------------------------------*/
18586                     /* SBB                                                                      */
18587
18588                     }
18589                   break;
18590               }
18591             break;
18592           case 0x01:
18593               GETBYTE ();
18594               switch (op[2] & 0x00)
18595               {
18596                 case 0x00:
18597                   goto op_semantics_144;
18598                   break;
18599               }
18600             break;
18601           case 0x02:
18602               GETBYTE ();
18603               switch (op[2] & 0x00)
18604               {
18605                 case 0x00:
18606                   goto op_semantics_144;
18607                   break;
18608               }
18609             break;
18610           case 0x03:
18611               GETBYTE ();
18612               switch (op[2] & 0x00)
18613               {
18614                 case 0x00:
18615                   goto op_semantics_144;
18616                   break;
18617               }
18618             break;
18619           case 0x04:
18620               GETBYTE ();
18621               switch (op[2] & 0x00)
18622               {
18623                 case 0x00:
18624                   goto op_semantics_144;
18625                   break;
18626               }
18627             break;
18628           case 0x05:
18629               GETBYTE ();
18630               switch (op[2] & 0x00)
18631               {
18632                 case 0x00:
18633                   goto op_semantics_144;
18634                   break;
18635               }
18636             break;
18637           case 0x06:
18638               GETBYTE ();
18639               switch (op[2] & 0x00)
18640               {
18641                 case 0x00:
18642                   goto op_semantics_144;
18643                   break;
18644               }
18645             break;
18646           case 0x07:
18647               GETBYTE ();
18648               switch (op[2] & 0x00)
18649               {
18650                 case 0x00:
18651                   goto op_semantics_144;
18652                   break;
18653               }
18654             break;
18655           case 0x08:
18656               GETBYTE ();
18657               switch (op[2] & 0x00)
18658               {
18659                 case 0x00:
18660                   goto op_semantics_144;
18661                   break;
18662               }
18663             break;
18664           case 0x09:
18665               GETBYTE ();
18666               switch (op[2] & 0x00)
18667               {
18668                 case 0x00:
18669                   goto op_semantics_144;
18670                   break;
18671               }
18672             break;
18673           case 0x0a:
18674               GETBYTE ();
18675               switch (op[2] & 0x00)
18676               {
18677                 case 0x00:
18678                   goto op_semantics_144;
18679                   break;
18680               }
18681             break;
18682           case 0x0b:
18683               GETBYTE ();
18684               switch (op[2] & 0x00)
18685               {
18686                 case 0x00:
18687                   goto op_semantics_144;
18688                   break;
18689               }
18690             break;
18691           case 0x0c:
18692               GETBYTE ();
18693               switch (op[2] & 0x00)
18694               {
18695                 case 0x00:
18696                   goto op_semantics_144;
18697                   break;
18698               }
18699             break;
18700           case 0x0d:
18701               GETBYTE ();
18702               switch (op[2] & 0x00)
18703               {
18704                 case 0x00:
18705                   goto op_semantics_144;
18706                   break;
18707               }
18708             break;
18709           case 0x0e:
18710               GETBYTE ();
18711               switch (op[2] & 0x00)
18712               {
18713                 case 0x00:
18714                   goto op_semantics_144;
18715                   break;
18716               }
18717             break;
18718           case 0x0f:
18719               GETBYTE ();
18720               switch (op[2] & 0x00)
18721               {
18722                 case 0x00:
18723                   goto op_semantics_144;
18724                   break;
18725               }
18726             break;
18727           case 0x20:
18728               GETBYTE ();
18729               switch (op[2] & 0x00)
18730               {
18731                 case 0x00:
18732                   op_semantics_145:
18733                     {
18734                       /** 1111 1111 0010 rdst srca srcb add     %2, %1, %0 */
18735 #line 537 "rx-decode.opc"
18736                       int rdst AU = op[1] & 0x0f;
18737 #line 537 "rx-decode.opc"
18738                       int srca AU = (op[2] >> 4) & 0x0f;
18739 #line 537 "rx-decode.opc"
18740                       int srcb AU = op[2] & 0x0f;
18741                       if (trace)
18742                         {
18743                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18744                                  "/** 1111 1111 0010 rdst srca srcb     add     %2, %1, %0 */",
18745                                  op[0], op[1], op[2]);
18746                           printf ("  rdst = 0x%x,", rdst);
18747                           printf ("  srca = 0x%x,", srca);
18748                           printf ("  srcb = 0x%x\n", srcb);
18749                         }
18750                       SYNTAX("add       %2, %1, %0");
18751 #line 537 "rx-decode.opc"
18752                       ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
18753
18754                     /*----------------------------------------------------------------------*/
18755                     /* CMP                                                                      */
18756
18757                     }
18758                   break;
18759               }
18760             break;
18761           case 0x21:
18762               GETBYTE ();
18763               switch (op[2] & 0x00)
18764               {
18765                 case 0x00:
18766                   goto op_semantics_145;
18767                   break;
18768               }
18769             break;
18770           case 0x22:
18771               GETBYTE ();
18772               switch (op[2] & 0x00)
18773               {
18774                 case 0x00:
18775                   goto op_semantics_145;
18776                   break;
18777               }
18778             break;
18779           case 0x23:
18780               GETBYTE ();
18781               switch (op[2] & 0x00)
18782               {
18783                 case 0x00:
18784                   goto op_semantics_145;
18785                   break;
18786               }
18787             break;
18788           case 0x24:
18789               GETBYTE ();
18790               switch (op[2] & 0x00)
18791               {
18792                 case 0x00:
18793                   goto op_semantics_145;
18794                   break;
18795               }
18796             break;
18797           case 0x25:
18798               GETBYTE ();
18799               switch (op[2] & 0x00)
18800               {
18801                 case 0x00:
18802                   goto op_semantics_145;
18803                   break;
18804               }
18805             break;
18806           case 0x26:
18807               GETBYTE ();
18808               switch (op[2] & 0x00)
18809               {
18810                 case 0x00:
18811                   goto op_semantics_145;
18812                   break;
18813               }
18814             break;
18815           case 0x27:
18816               GETBYTE ();
18817               switch (op[2] & 0x00)
18818               {
18819                 case 0x00:
18820                   goto op_semantics_145;
18821                   break;
18822               }
18823             break;
18824           case 0x28:
18825               GETBYTE ();
18826               switch (op[2] & 0x00)
18827               {
18828                 case 0x00:
18829                   goto op_semantics_145;
18830                   break;
18831               }
18832             break;
18833           case 0x29:
18834               GETBYTE ();
18835               switch (op[2] & 0x00)
18836               {
18837                 case 0x00:
18838                   goto op_semantics_145;
18839                   break;
18840               }
18841             break;
18842           case 0x2a:
18843               GETBYTE ();
18844               switch (op[2] & 0x00)
18845               {
18846                 case 0x00:
18847                   goto op_semantics_145;
18848                   break;
18849               }
18850             break;
18851           case 0x2b:
18852               GETBYTE ();
18853               switch (op[2] & 0x00)
18854               {
18855                 case 0x00:
18856                   goto op_semantics_145;
18857                   break;
18858               }
18859             break;
18860           case 0x2c:
18861               GETBYTE ();
18862               switch (op[2] & 0x00)
18863               {
18864                 case 0x00:
18865                   goto op_semantics_145;
18866                   break;
18867               }
18868             break;
18869           case 0x2d:
18870               GETBYTE ();
18871               switch (op[2] & 0x00)
18872               {
18873                 case 0x00:
18874                   goto op_semantics_145;
18875                   break;
18876               }
18877             break;
18878           case 0x2e:
18879               GETBYTE ();
18880               switch (op[2] & 0x00)
18881               {
18882                 case 0x00:
18883                   goto op_semantics_145;
18884                   break;
18885               }
18886             break;
18887           case 0x2f:
18888               GETBYTE ();
18889               switch (op[2] & 0x00)
18890               {
18891                 case 0x00:
18892                   goto op_semantics_145;
18893                   break;
18894               }
18895             break;
18896           case 0x30:
18897               GETBYTE ();
18898               switch (op[2] & 0x00)
18899               {
18900                 case 0x00:
18901                   op_semantics_146:
18902                     {
18903                       /** 1111 1111 0011 rdst srca srcb mul     %2, %1, %0 */
18904 #line 677 "rx-decode.opc"
18905                       int rdst AU = op[1] & 0x0f;
18906 #line 677 "rx-decode.opc"
18907                       int srca AU = (op[2] >> 4) & 0x0f;
18908 #line 677 "rx-decode.opc"
18909                       int srcb AU = op[2] & 0x0f;
18910                       if (trace)
18911                         {
18912                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
18913                                  "/** 1111 1111 0011 rdst srca srcb     mul     %2, %1, %0 */",
18914                                  op[0], op[1], op[2]);
18915                           printf ("  rdst = 0x%x,", rdst);
18916                           printf ("  srca = 0x%x,", srca);
18917                           printf ("  srcb = 0x%x\n", srcb);
18918                         }
18919                       SYNTAX("mul       %2, %1, %0");
18920 #line 677 "rx-decode.opc"
18921                       ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
18922
18923                     /*----------------------------------------------------------------------*/
18924                     /* EMUL                                                                     */
18925
18926                     }
18927                   break;
18928               }
18929             break;
18930           case 0x31:
18931               GETBYTE ();
18932               switch (op[2] & 0x00)
18933               {
18934                 case 0x00:
18935                   goto op_semantics_146;
18936                   break;
18937               }
18938             break;
18939           case 0x32:
18940               GETBYTE ();
18941               switch (op[2] & 0x00)
18942               {
18943                 case 0x00:
18944                   goto op_semantics_146;
18945                   break;
18946               }
18947             break;
18948           case 0x33:
18949               GETBYTE ();
18950               switch (op[2] & 0x00)
18951               {
18952                 case 0x00:
18953                   goto op_semantics_146;
18954                   break;
18955               }
18956             break;
18957           case 0x34:
18958               GETBYTE ();
18959               switch (op[2] & 0x00)
18960               {
18961                 case 0x00:
18962                   goto op_semantics_146;
18963                   break;
18964               }
18965             break;
18966           case 0x35:
18967               GETBYTE ();
18968               switch (op[2] & 0x00)
18969               {
18970                 case 0x00:
18971                   goto op_semantics_146;
18972                   break;
18973               }
18974             break;
18975           case 0x36:
18976               GETBYTE ();
18977               switch (op[2] & 0x00)
18978               {
18979                 case 0x00:
18980                   goto op_semantics_146;
18981                   break;
18982               }
18983             break;
18984           case 0x37:
18985               GETBYTE ();
18986               switch (op[2] & 0x00)
18987               {
18988                 case 0x00:
18989                   goto op_semantics_146;
18990                   break;
18991               }
18992             break;
18993           case 0x38:
18994               GETBYTE ();
18995               switch (op[2] & 0x00)
18996               {
18997                 case 0x00:
18998                   goto op_semantics_146;
18999                   break;
19000               }
19001             break;
19002           case 0x39:
19003               GETBYTE ();
19004               switch (op[2] & 0x00)
19005               {
19006                 case 0x00:
19007                   goto op_semantics_146;
19008                   break;
19009               }
19010             break;
19011           case 0x3a:
19012               GETBYTE ();
19013               switch (op[2] & 0x00)
19014               {
19015                 case 0x00:
19016                   goto op_semantics_146;
19017                   break;
19018               }
19019             break;
19020           case 0x3b:
19021               GETBYTE ();
19022               switch (op[2] & 0x00)
19023               {
19024                 case 0x00:
19025                   goto op_semantics_146;
19026                   break;
19027               }
19028             break;
19029           case 0x3c:
19030               GETBYTE ();
19031               switch (op[2] & 0x00)
19032               {
19033                 case 0x00:
19034                   goto op_semantics_146;
19035                   break;
19036               }
19037             break;
19038           case 0x3d:
19039               GETBYTE ();
19040               switch (op[2] & 0x00)
19041               {
19042                 case 0x00:
19043                   goto op_semantics_146;
19044                   break;
19045               }
19046             break;
19047           case 0x3e:
19048               GETBYTE ();
19049               switch (op[2] & 0x00)
19050               {
19051                 case 0x00:
19052                   goto op_semantics_146;
19053                   break;
19054               }
19055             break;
19056           case 0x3f:
19057               GETBYTE ();
19058               switch (op[2] & 0x00)
19059               {
19060                 case 0x00:
19061                   goto op_semantics_146;
19062                   break;
19063               }
19064             break;
19065           case 0x40:
19066               GETBYTE ();
19067               switch (op[2] & 0x00)
19068               {
19069                 case 0x00:
19070                   op_semantics_147:
19071                     {
19072                       /** 1111 1111 0100 rdst srca srcb and     %2, %1, %0 */
19073 #line 447 "rx-decode.opc"
19074                       int rdst AU = op[1] & 0x0f;
19075 #line 447 "rx-decode.opc"
19076                       int srca AU = (op[2] >> 4) & 0x0f;
19077 #line 447 "rx-decode.opc"
19078                       int srcb AU = op[2] & 0x0f;
19079                       if (trace)
19080                         {
19081                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19082                                  "/** 1111 1111 0100 rdst srca srcb     and     %2, %1, %0 */",
19083                                  op[0], op[1], op[2]);
19084                           printf ("  rdst = 0x%x,", rdst);
19085                           printf ("  srca = 0x%x,", srca);
19086                           printf ("  srcb = 0x%x\n", srcb);
19087                         }
19088                       SYNTAX("and       %2, %1, %0");
19089 #line 447 "rx-decode.opc"
19090                       ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19091
19092                     /*----------------------------------------------------------------------*/
19093                     /* OR                                                                       */
19094
19095                     }
19096                   break;
19097               }
19098             break;
19099           case 0x41:
19100               GETBYTE ();
19101               switch (op[2] & 0x00)
19102               {
19103                 case 0x00:
19104                   goto op_semantics_147;
19105                   break;
19106               }
19107             break;
19108           case 0x42:
19109               GETBYTE ();
19110               switch (op[2] & 0x00)
19111               {
19112                 case 0x00:
19113                   goto op_semantics_147;
19114                   break;
19115               }
19116             break;
19117           case 0x43:
19118               GETBYTE ();
19119               switch (op[2] & 0x00)
19120               {
19121                 case 0x00:
19122                   goto op_semantics_147;
19123                   break;
19124               }
19125             break;
19126           case 0x44:
19127               GETBYTE ();
19128               switch (op[2] & 0x00)
19129               {
19130                 case 0x00:
19131                   goto op_semantics_147;
19132                   break;
19133               }
19134             break;
19135           case 0x45:
19136               GETBYTE ();
19137               switch (op[2] & 0x00)
19138               {
19139                 case 0x00:
19140                   goto op_semantics_147;
19141                   break;
19142               }
19143             break;
19144           case 0x46:
19145               GETBYTE ();
19146               switch (op[2] & 0x00)
19147               {
19148                 case 0x00:
19149                   goto op_semantics_147;
19150                   break;
19151               }
19152             break;
19153           case 0x47:
19154               GETBYTE ();
19155               switch (op[2] & 0x00)
19156               {
19157                 case 0x00:
19158                   goto op_semantics_147;
19159                   break;
19160               }
19161             break;
19162           case 0x48:
19163               GETBYTE ();
19164               switch (op[2] & 0x00)
19165               {
19166                 case 0x00:
19167                   goto op_semantics_147;
19168                   break;
19169               }
19170             break;
19171           case 0x49:
19172               GETBYTE ();
19173               switch (op[2] & 0x00)
19174               {
19175                 case 0x00:
19176                   goto op_semantics_147;
19177                   break;
19178               }
19179             break;
19180           case 0x4a:
19181               GETBYTE ();
19182               switch (op[2] & 0x00)
19183               {
19184                 case 0x00:
19185                   goto op_semantics_147;
19186                   break;
19187               }
19188             break;
19189           case 0x4b:
19190               GETBYTE ();
19191               switch (op[2] & 0x00)
19192               {
19193                 case 0x00:
19194                   goto op_semantics_147;
19195                   break;
19196               }
19197             break;
19198           case 0x4c:
19199               GETBYTE ();
19200               switch (op[2] & 0x00)
19201               {
19202                 case 0x00:
19203                   goto op_semantics_147;
19204                   break;
19205               }
19206             break;
19207           case 0x4d:
19208               GETBYTE ();
19209               switch (op[2] & 0x00)
19210               {
19211                 case 0x00:
19212                   goto op_semantics_147;
19213                   break;
19214               }
19215             break;
19216           case 0x4e:
19217               GETBYTE ();
19218               switch (op[2] & 0x00)
19219               {
19220                 case 0x00:
19221                   goto op_semantics_147;
19222                   break;
19223               }
19224             break;
19225           case 0x4f:
19226               GETBYTE ();
19227               switch (op[2] & 0x00)
19228               {
19229                 case 0x00:
19230                   goto op_semantics_147;
19231                   break;
19232               }
19233             break;
19234           case 0x50:
19235               GETBYTE ();
19236               switch (op[2] & 0x00)
19237               {
19238                 case 0x00:
19239                   op_semantics_148:
19240                     {
19241                       /** 1111 1111 0101 rdst srca srcb or      %2, %1, %0 */
19242 #line 465 "rx-decode.opc"
19243                       int rdst AU = op[1] & 0x0f;
19244 #line 465 "rx-decode.opc"
19245                       int srca AU = (op[2] >> 4) & 0x0f;
19246 #line 465 "rx-decode.opc"
19247                       int srcb AU = op[2] & 0x0f;
19248                       if (trace)
19249                         {
19250                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19251                                  "/** 1111 1111 0101 rdst srca srcb     or      %2, %1, %0 */",
19252                                  op[0], op[1], op[2]);
19253                           printf ("  rdst = 0x%x,", rdst);
19254                           printf ("  srca = 0x%x,", srca);
19255                           printf ("  srcb = 0x%x\n", srcb);
19256                         }
19257                       SYNTAX("or        %2, %1, %0");
19258 #line 465 "rx-decode.opc"
19259                       ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19260
19261                     /*----------------------------------------------------------------------*/
19262                     /* XOR                                                                      */
19263
19264                     }
19265                   break;
19266               }
19267             break;
19268           case 0x51:
19269               GETBYTE ();
19270               switch (op[2] & 0x00)
19271               {
19272                 case 0x00:
19273                   goto op_semantics_148;
19274                   break;
19275               }
19276             break;
19277           case 0x52:
19278               GETBYTE ();
19279               switch (op[2] & 0x00)
19280               {
19281                 case 0x00:
19282                   goto op_semantics_148;
19283                   break;
19284               }
19285             break;
19286           case 0x53:
19287               GETBYTE ();
19288               switch (op[2] & 0x00)
19289               {
19290                 case 0x00:
19291                   goto op_semantics_148;
19292                   break;
19293               }
19294             break;
19295           case 0x54:
19296               GETBYTE ();
19297               switch (op[2] & 0x00)
19298               {
19299                 case 0x00:
19300                   goto op_semantics_148;
19301                   break;
19302               }
19303             break;
19304           case 0x55:
19305               GETBYTE ();
19306               switch (op[2] & 0x00)
19307               {
19308                 case 0x00:
19309                   goto op_semantics_148;
19310                   break;
19311               }
19312             break;
19313           case 0x56:
19314               GETBYTE ();
19315               switch (op[2] & 0x00)
19316               {
19317                 case 0x00:
19318                   goto op_semantics_148;
19319                   break;
19320               }
19321             break;
19322           case 0x57:
19323               GETBYTE ();
19324               switch (op[2] & 0x00)
19325               {
19326                 case 0x00:
19327                   goto op_semantics_148;
19328                   break;
19329               }
19330             break;
19331           case 0x58:
19332               GETBYTE ();
19333               switch (op[2] & 0x00)
19334               {
19335                 case 0x00:
19336                   goto op_semantics_148;
19337                   break;
19338               }
19339             break;
19340           case 0x59:
19341               GETBYTE ();
19342               switch (op[2] & 0x00)
19343               {
19344                 case 0x00:
19345                   goto op_semantics_148;
19346                   break;
19347               }
19348             break;
19349           case 0x5a:
19350               GETBYTE ();
19351               switch (op[2] & 0x00)
19352               {
19353                 case 0x00:
19354                   goto op_semantics_148;
19355                   break;
19356               }
19357             break;
19358           case 0x5b:
19359               GETBYTE ();
19360               switch (op[2] & 0x00)
19361               {
19362                 case 0x00:
19363                   goto op_semantics_148;
19364                   break;
19365               }
19366             break;
19367           case 0x5c:
19368               GETBYTE ();
19369               switch (op[2] & 0x00)
19370               {
19371                 case 0x00:
19372                   goto op_semantics_148;
19373                   break;
19374               }
19375             break;
19376           case 0x5d:
19377               GETBYTE ();
19378               switch (op[2] & 0x00)
19379               {
19380                 case 0x00:
19381                   goto op_semantics_148;
19382                   break;
19383               }
19384             break;
19385           case 0x5e:
19386               GETBYTE ();
19387               switch (op[2] & 0x00)
19388               {
19389                 case 0x00:
19390                   goto op_semantics_148;
19391                   break;
19392               }
19393             break;
19394           case 0x5f:
19395               GETBYTE ();
19396               switch (op[2] & 0x00)
19397               {
19398                 case 0x00:
19399                   goto op_semantics_148;
19400                   break;
19401               }
19402             break;
19403           case 0x60:
19404               GETBYTE ();
19405               switch (op[2] & 0x00)
19406               {
19407                 case 0x00:
19408                   op_semantics_149:
19409                     {
19410                       /** 1111 1111 0110 rdst srca srcb xor     %2, %1, %0 */
19411 #line 1146 "rx-decode.opc"
19412                       int rdst AU = op[1] & 0x0f;
19413 #line 1146 "rx-decode.opc"
19414                       int srca AU = (op[2] >> 4) & 0x0f;
19415 #line 1146 "rx-decode.opc"
19416                       int srcb AU = op[2] & 0x0f;
19417                       if (trace)
19418                         {
19419                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19420                                  "/** 1111 1111 0110 rdst srca srcb     xor     %2, %1, %0 */",
19421                                  op[0], op[1], op[2]);
19422                           printf ("  rdst = 0x%x,", rdst);
19423                           printf ("  srca = 0x%x,", srca);
19424                           printf ("  srcb = 0x%x\n", srcb);
19425                         }
19426                       SYNTAX("xor       %2, %1, %0");
19427 #line 1146 "rx-decode.opc"
19428                       ID(xor); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19429
19430                     }
19431                   break;
19432               }
19433             break;
19434           case 0x61:
19435               GETBYTE ();
19436               switch (op[2] & 0x00)
19437               {
19438                 case 0x00:
19439                   goto op_semantics_149;
19440                   break;
19441               }
19442             break;
19443           case 0x62:
19444               GETBYTE ();
19445               switch (op[2] & 0x00)
19446               {
19447                 case 0x00:
19448                   goto op_semantics_149;
19449                   break;
19450               }
19451             break;
19452           case 0x63:
19453               GETBYTE ();
19454               switch (op[2] & 0x00)
19455               {
19456                 case 0x00:
19457                   goto op_semantics_149;
19458                   break;
19459               }
19460             break;
19461           case 0x64:
19462               GETBYTE ();
19463               switch (op[2] & 0x00)
19464               {
19465                 case 0x00:
19466                   goto op_semantics_149;
19467                   break;
19468               }
19469             break;
19470           case 0x65:
19471               GETBYTE ();
19472               switch (op[2] & 0x00)
19473               {
19474                 case 0x00:
19475                   goto op_semantics_149;
19476                   break;
19477               }
19478             break;
19479           case 0x66:
19480               GETBYTE ();
19481               switch (op[2] & 0x00)
19482               {
19483                 case 0x00:
19484                   goto op_semantics_149;
19485                   break;
19486               }
19487             break;
19488           case 0x67:
19489               GETBYTE ();
19490               switch (op[2] & 0x00)
19491               {
19492                 case 0x00:
19493                   goto op_semantics_149;
19494                   break;
19495               }
19496             break;
19497           case 0x68:
19498               GETBYTE ();
19499               switch (op[2] & 0x00)
19500               {
19501                 case 0x00:
19502                   goto op_semantics_149;
19503                   break;
19504               }
19505             break;
19506           case 0x69:
19507               GETBYTE ();
19508               switch (op[2] & 0x00)
19509               {
19510                 case 0x00:
19511                   goto op_semantics_149;
19512                   break;
19513               }
19514             break;
19515           case 0x6a:
19516               GETBYTE ();
19517               switch (op[2] & 0x00)
19518               {
19519                 case 0x00:
19520                   goto op_semantics_149;
19521                   break;
19522               }
19523             break;
19524           case 0x6b:
19525               GETBYTE ();
19526               switch (op[2] & 0x00)
19527               {
19528                 case 0x00:
19529                   goto op_semantics_149;
19530                   break;
19531               }
19532             break;
19533           case 0x6c:
19534               GETBYTE ();
19535               switch (op[2] & 0x00)
19536               {
19537                 case 0x00:
19538                   goto op_semantics_149;
19539                   break;
19540               }
19541             break;
19542           case 0x6d:
19543               GETBYTE ();
19544               switch (op[2] & 0x00)
19545               {
19546                 case 0x00:
19547                   goto op_semantics_149;
19548                   break;
19549               }
19550             break;
19551           case 0x6e:
19552               GETBYTE ();
19553               switch (op[2] & 0x00)
19554               {
19555                 case 0x00:
19556                   goto op_semantics_149;
19557                   break;
19558               }
19559             break;
19560           case 0x6f:
19561               GETBYTE ();
19562               switch (op[2] & 0x00)
19563               {
19564                 case 0x00:
19565                   goto op_semantics_149;
19566                   break;
19567               }
19568             break;
19569           case 0x80:
19570               GETBYTE ();
19571               switch (op[2] & 0x00)
19572               {
19573                 case 0x00:
19574                   op_semantics_150:
19575                     {
19576                       /** 1111 1111 1000 rdst srca srcb fsub    %2, %1, %0 */
19577 #line 1125 "rx-decode.opc"
19578                       int rdst AU = op[1] & 0x0f;
19579 #line 1125 "rx-decode.opc"
19580                       int srca AU = (op[2] >> 4) & 0x0f;
19581 #line 1125 "rx-decode.opc"
19582                       int srcb AU = op[2] & 0x0f;
19583                       if (trace)
19584                         {
19585                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19586                                  "/** 1111 1111 1000 rdst srca srcb     fsub    %2, %1, %0 */",
19587                                  op[0], op[1], op[2]);
19588                           printf ("  rdst = 0x%x,", rdst);
19589                           printf ("  srca = 0x%x,", srca);
19590                           printf ("  srcb = 0x%x\n", srcb);
19591                         }
19592                       SYNTAX("fsub      %2, %1, %0");
19593 #line 1125 "rx-decode.opc"
19594                       ID(fsub); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19595
19596                     }
19597                   break;
19598               }
19599             break;
19600           case 0x81:
19601               GETBYTE ();
19602               switch (op[2] & 0x00)
19603               {
19604                 case 0x00:
19605                   goto op_semantics_150;
19606                   break;
19607               }
19608             break;
19609           case 0x82:
19610               GETBYTE ();
19611               switch (op[2] & 0x00)
19612               {
19613                 case 0x00:
19614                   goto op_semantics_150;
19615                   break;
19616               }
19617             break;
19618           case 0x83:
19619               GETBYTE ();
19620               switch (op[2] & 0x00)
19621               {
19622                 case 0x00:
19623                   goto op_semantics_150;
19624                   break;
19625               }
19626             break;
19627           case 0x84:
19628               GETBYTE ();
19629               switch (op[2] & 0x00)
19630               {
19631                 case 0x00:
19632                   goto op_semantics_150;
19633                   break;
19634               }
19635             break;
19636           case 0x85:
19637               GETBYTE ();
19638               switch (op[2] & 0x00)
19639               {
19640                 case 0x00:
19641                   goto op_semantics_150;
19642                   break;
19643               }
19644             break;
19645           case 0x86:
19646               GETBYTE ();
19647               switch (op[2] & 0x00)
19648               {
19649                 case 0x00:
19650                   goto op_semantics_150;
19651                   break;
19652               }
19653             break;
19654           case 0x87:
19655               GETBYTE ();
19656               switch (op[2] & 0x00)
19657               {
19658                 case 0x00:
19659                   goto op_semantics_150;
19660                   break;
19661               }
19662             break;
19663           case 0x88:
19664               GETBYTE ();
19665               switch (op[2] & 0x00)
19666               {
19667                 case 0x00:
19668                   goto op_semantics_150;
19669                   break;
19670               }
19671             break;
19672           case 0x89:
19673               GETBYTE ();
19674               switch (op[2] & 0x00)
19675               {
19676                 case 0x00:
19677                   goto op_semantics_150;
19678                   break;
19679               }
19680             break;
19681           case 0x8a:
19682               GETBYTE ();
19683               switch (op[2] & 0x00)
19684               {
19685                 case 0x00:
19686                   goto op_semantics_150;
19687                   break;
19688               }
19689             break;
19690           case 0x8b:
19691               GETBYTE ();
19692               switch (op[2] & 0x00)
19693               {
19694                 case 0x00:
19695                   goto op_semantics_150;
19696                   break;
19697               }
19698             break;
19699           case 0x8c:
19700               GETBYTE ();
19701               switch (op[2] & 0x00)
19702               {
19703                 case 0x00:
19704                   goto op_semantics_150;
19705                   break;
19706               }
19707             break;
19708           case 0x8d:
19709               GETBYTE ();
19710               switch (op[2] & 0x00)
19711               {
19712                 case 0x00:
19713                   goto op_semantics_150;
19714                   break;
19715               }
19716             break;
19717           case 0x8e:
19718               GETBYTE ();
19719               switch (op[2] & 0x00)
19720               {
19721                 case 0x00:
19722                   goto op_semantics_150;
19723                   break;
19724               }
19725             break;
19726           case 0x8f:
19727               GETBYTE ();
19728               switch (op[2] & 0x00)
19729               {
19730                 case 0x00:
19731                   goto op_semantics_150;
19732                   break;
19733               }
19734             break;
19735           case 0xa0:
19736               GETBYTE ();
19737               switch (op[2] & 0x00)
19738               {
19739                 case 0x00:
19740                   op_semantics_151:
19741                     {
19742                       /** 1111 1111 1010 rdst srca srcb fadd    %2, %1, %0 */
19743 #line 1122 "rx-decode.opc"
19744                       int rdst AU = op[1] & 0x0f;
19745 #line 1122 "rx-decode.opc"
19746                       int srca AU = (op[2] >> 4) & 0x0f;
19747 #line 1122 "rx-decode.opc"
19748                       int srcb AU = op[2] & 0x0f;
19749                       if (trace)
19750                         {
19751                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19752                                  "/** 1111 1111 1010 rdst srca srcb     fadd    %2, %1, %0 */",
19753                                  op[0], op[1], op[2]);
19754                           printf ("  rdst = 0x%x,", rdst);
19755                           printf ("  srca = 0x%x,", srca);
19756                           printf ("  srcb = 0x%x\n", srcb);
19757                         }
19758                       SYNTAX("fadd      %2, %1, %0");
19759 #line 1122 "rx-decode.opc"
19760                       ID(fadd); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19761
19762                     }
19763                   break;
19764               }
19765             break;
19766           case 0xa1:
19767               GETBYTE ();
19768               switch (op[2] & 0x00)
19769               {
19770                 case 0x00:
19771                   goto op_semantics_151;
19772                   break;
19773               }
19774             break;
19775           case 0xa2:
19776               GETBYTE ();
19777               switch (op[2] & 0x00)
19778               {
19779                 case 0x00:
19780                   goto op_semantics_151;
19781                   break;
19782               }
19783             break;
19784           case 0xa3:
19785               GETBYTE ();
19786               switch (op[2] & 0x00)
19787               {
19788                 case 0x00:
19789                   goto op_semantics_151;
19790                   break;
19791               }
19792             break;
19793           case 0xa4:
19794               GETBYTE ();
19795               switch (op[2] & 0x00)
19796               {
19797                 case 0x00:
19798                   goto op_semantics_151;
19799                   break;
19800               }
19801             break;
19802           case 0xa5:
19803               GETBYTE ();
19804               switch (op[2] & 0x00)
19805               {
19806                 case 0x00:
19807                   goto op_semantics_151;
19808                   break;
19809               }
19810             break;
19811           case 0xa6:
19812               GETBYTE ();
19813               switch (op[2] & 0x00)
19814               {
19815                 case 0x00:
19816                   goto op_semantics_151;
19817                   break;
19818               }
19819             break;
19820           case 0xa7:
19821               GETBYTE ();
19822               switch (op[2] & 0x00)
19823               {
19824                 case 0x00:
19825                   goto op_semantics_151;
19826                   break;
19827               }
19828             break;
19829           case 0xa8:
19830               GETBYTE ();
19831               switch (op[2] & 0x00)
19832               {
19833                 case 0x00:
19834                   goto op_semantics_151;
19835                   break;
19836               }
19837             break;
19838           case 0xa9:
19839               GETBYTE ();
19840               switch (op[2] & 0x00)
19841               {
19842                 case 0x00:
19843                   goto op_semantics_151;
19844                   break;
19845               }
19846             break;
19847           case 0xaa:
19848               GETBYTE ();
19849               switch (op[2] & 0x00)
19850               {
19851                 case 0x00:
19852                   goto op_semantics_151;
19853                   break;
19854               }
19855             break;
19856           case 0xab:
19857               GETBYTE ();
19858               switch (op[2] & 0x00)
19859               {
19860                 case 0x00:
19861                   goto op_semantics_151;
19862                   break;
19863               }
19864             break;
19865           case 0xac:
19866               GETBYTE ();
19867               switch (op[2] & 0x00)
19868               {
19869                 case 0x00:
19870                   goto op_semantics_151;
19871                   break;
19872               }
19873             break;
19874           case 0xad:
19875               GETBYTE ();
19876               switch (op[2] & 0x00)
19877               {
19878                 case 0x00:
19879                   goto op_semantics_151;
19880                   break;
19881               }
19882             break;
19883           case 0xae:
19884               GETBYTE ();
19885               switch (op[2] & 0x00)
19886               {
19887                 case 0x00:
19888                   goto op_semantics_151;
19889                   break;
19890               }
19891             break;
19892           case 0xaf:
19893               GETBYTE ();
19894               switch (op[2] & 0x00)
19895               {
19896                 case 0x00:
19897                   goto op_semantics_151;
19898                   break;
19899               }
19900             break;
19901           case 0xb0:
19902               GETBYTE ();
19903               switch (op[2] & 0x00)
19904               {
19905                 case 0x00:
19906                   op_semantics_152:
19907                     {
19908                       /** 1111 1111 1011 rdst srca srcb fmul    %2, %1, %0 */
19909 #line 1128 "rx-decode.opc"
19910                       int rdst AU = op[1] & 0x0f;
19911 #line 1128 "rx-decode.opc"
19912                       int srca AU = (op[2] >> 4) & 0x0f;
19913 #line 1128 "rx-decode.opc"
19914                       int srcb AU = op[2] & 0x0f;
19915                       if (trace)
19916                         {
19917                           printf ("\033[33m%s\033[0m  %02x %02x %02x\n",
19918                                  "/** 1111 1111 1011 rdst srca srcb     fmul    %2, %1, %0 */",
19919                                  op[0], op[1], op[2]);
19920                           printf ("  rdst = 0x%x,", rdst);
19921                           printf ("  srca = 0x%x,", srca);
19922                           printf ("  srcb = 0x%x\n", srcb);
19923                         }
19924                       SYNTAX("fmul      %2, %1, %0");
19925 #line 1128 "rx-decode.opc"
19926                       ID(fmul); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
19927
19928                     }
19929                   break;
19930               }
19931             break;
19932           case 0xb1:
19933               GETBYTE ();
19934               switch (op[2] & 0x00)
19935               {
19936                 case 0x00:
19937                   goto op_semantics_152;
19938                   break;
19939               }
19940             break;
19941           case 0xb2:
19942               GETBYTE ();
19943               switch (op[2] & 0x00)
19944               {
19945                 case 0x00:
19946                   goto op_semantics_152;
19947                   break;
19948               }
19949             break;
19950           case 0xb3:
19951               GETBYTE ();
19952               switch (op[2] & 0x00)
19953               {
19954                 case 0x00:
19955                   goto op_semantics_152;
19956                   break;
19957               }
19958             break;
19959           case 0xb4:
19960               GETBYTE ();
19961               switch (op[2] & 0x00)
19962               {
19963                 case 0x00:
19964                   goto op_semantics_152;
19965                   break;
19966               }
19967             break;
19968           case 0xb5:
19969               GETBYTE ();
19970               switch (op[2] & 0x00)
19971               {
19972                 case 0x00:
19973                   goto op_semantics_152;
19974                   break;
19975               }
19976             break;
19977           case 0xb6:
19978               GETBYTE ();
19979               switch (op[2] & 0x00)
19980               {
19981                 case 0x00:
19982                   goto op_semantics_152;
19983                   break;
19984               }
19985             break;
19986           case 0xb7:
19987               GETBYTE ();
19988               switch (op[2] & 0x00)
19989               {
19990                 case 0x00:
19991                   goto op_semantics_152;
19992                   break;
19993               }
19994             break;
19995           case 0xb8:
19996               GETBYTE ();
19997               switch (op[2] & 0x00)
19998               {
19999                 case 0x00:
20000                   goto op_semantics_152;
20001                   break;
20002               }
20003             break;
20004           case 0xb9:
20005               GETBYTE ();
20006               switch (op[2] & 0x00)
20007               {
20008                 case 0x00:
20009                   goto op_semantics_152;
20010                   break;
20011               }
20012             break;
20013           case 0xba:
20014               GETBYTE ();
20015               switch (op[2] & 0x00)
20016               {
20017                 case 0x00:
20018                   goto op_semantics_152;
20019                   break;
20020               }
20021             break;
20022           case 0xbb:
20023               GETBYTE ();
20024               switch (op[2] & 0x00)
20025               {
20026                 case 0x00:
20027                   goto op_semantics_152;
20028                   break;
20029               }
20030             break;
20031           case 0xbc:
20032               GETBYTE ();
20033               switch (op[2] & 0x00)
20034               {
20035                 case 0x00:
20036                   goto op_semantics_152;
20037                   break;
20038               }
20039             break;
20040           case 0xbd:
20041               GETBYTE ();
20042               switch (op[2] & 0x00)
20043               {
20044                 case 0x00:
20045                   goto op_semantics_152;
20046                   break;
20047               }
20048             break;
20049           case 0xbe:
20050               GETBYTE ();
20051               switch (op[2] & 0x00)
20052               {
20053                 case 0x00:
20054                   goto op_semantics_152;
20055                   break;
20056               }
20057             break;
20058           case 0xbf:
20059               GETBYTE ();
20060               switch (op[2] & 0x00)
20061               {
20062                 case 0x00:
20063                   goto op_semantics_152;
20064                   break;
20065               }
20066             break;
20067           default: UNSUPPORTED(); break;
20068         }
20069       break;
20070     default: UNSUPPORTED(); break;
20071   }
20072 #line 1280 "rx-decode.opc"
20073
20074   return rx->n_bytes;
20075 }